Borland C++, üç ana() argümanı destekler. İlk ikisi geleneksel argc ve argv'dir. tek argüman bunlar ana fonksiyonlar(), ANSI C standardı tarafından tanımlanır.Programa komut satırı argümanlarının iletilmesine izin verirler. Komut satırı argümanları, program adından sonra gelen bilgilerdir. Komut satırı işletim sistemi. Örneğin, bir program Borland satır içi derleyicisiyle derlendiğinde, genellikle bcc yazılır. program adı

Neresi program adı derlenecek programdır. Program adı, derleyiciye argüman olarak iletilir.

argc parametresi, komut satırı argümanlarının sayısını içerir ve bir tamsayıdır. Program adı ilk argüman olarak nitelendiğinden her zaman en az 1'dir. argv parametresi, bir dizi karakter işaretçisi için bir işaretçidir. Bu dizinin her elemanı bir komut satırı argümanına işaret eder. Tüm komut satırı bağımsız değişkenleri dizelerdir. Tüm sayılar program tarafından dahili bir biçime dönüştürülür. Aşağıdaki program, program adından hemen sonra yazıldığında kullanıcı adının ardından "Merhaba" yazar:

#Dahil etmek

{
if(argc!=2)
{
printf("Adınızı yazmayı unuttunuz\n");
dönüş 1;
}
printf("Merhaba %s", argv);
0 döndür;
}

çağrılırsa bu program ad ve kullanıcı adı Sergey, ardından programı çalıştırmak için şunu yazmalısınız:
adı Sergey.
Programın bir sonucu olarak görünecektir:
Merhaba Sergey.

Komut satırı bağımsız değişkenleri boşluk veya sekmelerle ayrılmalıdır. Virgül, noktalı virgül ve benzeri karakterler ayırıcı olarak kabul edilmez. Örneğin:

Üç satırdan oluşurken

Bitki, Rick, Fred

Bu bir satırdır - virgül sınırlayıcı değildir.

Tek bir argüman olarak boşluklar veya sekmeler içeren bir dize iletmek istiyorsanız, onu içine alın. ikili alıntı. Örneğin, bu bir argümandır:

"bu bir test"

argv'yi doğru bir şekilde bildirmek önemlidir. En tipik yöntem şudur:

Boş parantezler, dizinin sabit bir uzunluğu olmadığını gösterir. Argv indekslemeyi kullanarak tek tek öğelere erişebilirsiniz. Örneğin, argv her zaman programın adını içeren ilk satırı işaret eder. argv sonraki satırı işaret eder, vb.

Aşağıda komut satırı argümanlarını kullanmanın küçük bir örneği verilmiştir. Komut satırında belirtilen değerden geriye doğru sayar ve sıfıra ulaşıldığında sinyal verir. İlk bağımsız değişkenin, standart atoi() işlevi kullanılarak bir tam sayıya dönüştürülmüş bir sayı içerdiğine dikkat edin. "Display" dizisi ikinci argüman olarak mevcutsa, sayacın kendisi ekranda görüntülenecektir.

/* sayma programı */

#Dahil etmek
#Dahil etmek
#Dahil etmek
int ana(int argc, karakter *argv)
{
int disp, say;
if(argc<2)
{
printf("Sayımın uzunluğunu girmelisiniz\n");
printf("komut satırında. Tekrar deneyin.\n");
dönüş 1;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
başka disp = 0;
for(sayım=atoi(argv); say; -say)
if (disp) printf("%d", sayım);
printf("%c", "\a"); /* çoğu bilgisayarda bu bir aramadır */
0 döndür;
}

Hiçbir argüman belirtilmezse bir hata mesajı görüneceğini unutmayın. Bu, programı doğru bilgi olmadan çalıştırma girişiminde bulunulursa, talimat vermek için komut satırı bağımsız değişkenlerini kullanan programların en tipik örneğidir.

Tek tek komut satırı karakterlerine erişmek için argv'ye ikinci bir dizin ekleyin. Örneğin, aşağıdaki program, çağrıldığı tüm argümanları her seferinde bir karakter olacak şekilde yazdırır:

#Dahil etmek
int ana(int argc, karakter *argv)
{
int t, ben;
for(t=0; t {
ben = 0;
while(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(");
}
0 döndür;
}

Unutulmamalıdır ki, ilk indeks dizgeye erişim içindir, ikincisi ise dizginin karakterine erişim içindir.

Kaynak komutlarını almak için genellikle argc ve argv kullanılır. Teorik olarak 32767'ye kadar argümanınız olabilir, ancak çoğu işletim sistemi buna yaklaşmanıza bile izin vermez. Tipik olarak, bu argümanlar bir dosya adı veya seçenekler belirtmek için kullanılır. Komut satırı argümanlarının kullanılması, programa profesyonel bir görünüm kazandırır ve programın toplu iş dosyalarında kullanılmasına izin verir.

Borland C++ ile sağlanan WILDARGS.OBJ dosyasını eklerseniz, *.EXE türü bağımsız değişkenlerde joker karakterler kullanabilirsiniz. (Borland C++, kalıpları otomatik olarak işler ve argc'yi buna göre artırır.) Örneğin, WILDARGS.OBJ'yi aşağıdaki programa bağlarsanız, komut satırında belirtilen dosya adıyla kaç dosyanın eşleştiğini yazdırır:

/* Bu programı WILDARGS.OBJ ile bağla */

#Dahil etmek
int ana(int argc, karakter *argv)
{
int i'yi kaydedin;
printf("%d dosya belirtilen adla eşleşiyor\n", argc-1);
printf("Bunlar: ");
için(i=1; ben printf("%s", argv[i]);
0 döndür;
}

Bu programı WA olarak adlandırırsak, aşağıdaki gibi çalıştırın, EXE uzantısına sahip dosyaların sayısını ve bu dosyaların adlarının bir listesini alırız:

argc ve argv'ye ek olarak, Borland C++ ayrıca üçüncü bir komut satırı argümanı -env sağlar. env parametresi, programın işletim sistemi ortamı hakkındaki bilgilere erişmesini sağlar. env parametresi argc ve argv'yi takip etmeli ve şu şekilde bildirilmelidir:

Gördüğünüz gibi env, argv ile aynı şekilde bildirilir. Tıpkı argv gibi, bu da bir dizi dizi için bir işaretçidir. Her satır, işletim sistemi tarafından tanımlanan bir ortam dizesidir. env parametresinin, kaç tane ortam satırı olduğunu söyleyen argc parametresinin karşılığı yoktur. Bunun yerine, ortamın son satırı boştur. Aşağıdaki program, işletim sisteminde halihazırda tanımlanmış olan tüm ortam dizelerini yazdırır:

/* bu program tüm ortam satırlarını yazdırır */

#Dahil etmek
int main(int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]/ t++)
printf("%s\n", env[t]);
0 döndür;
}

argc ve argv program tarafından kullanılmasa da, parametre listesinde bulunmaları gerektiğini unutmayın. C parametre adlarını bilmiyor. Bunun yerine kullanımları, parametrelerin bildirildiği sıraya göre belirlenir. Aslında, parametreyi istediğiniz gibi arayabilirsiniz. argc, argv ve env geleneksel isimler olduğundan, programı okuyan herkesin bunların main() işlevinin argümanları olduğunu anında anlayabilmesi için bunları kullanmaya devam etmek en iyisidir.

Programlar için tipik bir görev, ortam dizesinde tanımlanan değeri bulmaktır. Örneğin, PATH dizesinin içeriği, programların arama yollarını kullanmasına izin verir. Aşağıdaki program, standart arama yollarını bildiren dizelerin nasıl bulunacağını gösterir. Aşağıdaki prototipe sahip standart kitaplık işlevi strstr()'yi kullanır:

Karakter *strstr(const char *str1, const char *str2);

strstr() işlevi, str2 ile gösterilen dizede str1 ile gösterilen dizeyi arar. Böyle bir dize bulunursa, ilk konuma bir işaretçi döndürülür. Eşleşme bulunamazsa, işlev NULL döndürür.

/* program PATH içeren bir dizi için ortam dizilerini arar */

#Dahil etmek
#Dahil etmek
int ana (int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]; t++)
{
if(strstr(env[t], "YOL"))
printf("%s\n", env[t]);
}
0 döndür;
}

C++ programlama dilinde bir konsol uygulaması oluştururken, buna çok benzer bir satır otomatik olarak oluşturulur:

int main(int argc, char* argv) // main() fonksiyon parametreleri

Bu satır main() ana işlevinin başlığıdır, argс ve argv parametreleri parantez içinde belirtilir. Yani, program komut satırı üzerinden çalıştırılırsa, bu programa herhangi bir bilgiyi aktarmak mümkündür, bunun için argc ve argv parametreleri vardır. argc parametresi int veri türündedir ve ana işleve geçirilen parametre sayısını içerir. Ayrıca, fonksiyonun adı ilk parametre olarak kabul edildiğinden, herhangi bir bilgi iletmesek bile, argc her zaman en az 1'dir. argv parametresi, dizelere yönelik bir işaretçi dizisidir. Komut satırından yalnızca dize türü veriler geçirilebilir. İşaretçiler ve dizeler, ayrı bölümler oluşturulmuş iki büyük konudur. Bu nedenle, herhangi bir bilginin iletilmesi argv parametresi aracılığıyla olur. Windows komut satırı üzerinden çalıştıracağımız bir program geliştirelim ve ona bazı bilgiler aktaralım.

// argc_argv.cpp: Konsol uygulaması için giriş noktasını belirtir. #include "stdafx.h" #include ad alanı std kullanarak; int main(int argc, char* argv) ( if (argc ><< argv<

// kod Kod::Bloklar

// Dev-C++ kodu

// argc_argv.cpp: Konsol uygulaması için giriş noktasını belirtir. #Dahil etmek ad alanı std kullanarak; int main(int argc, char* argv) ( if (argc > 1)// argümanları iletirsek, argc 1'den büyük olacaktır (argüman sayısına bağlı olarak) ( cout<< argv<

Programın hatalarını ayıkladıktan sonra, Windows komut satırını açın ve programımızın yürütülebilir dosyasını komut satırı penceresine sürükleyin, programın tam yolu komut satırında görüntülenecektir (ancak programın yolunu manuel olarak yazabilirsiniz), sonra basabileceğiniz GİRMEK ve program başlayacaktır (bkz. Şekil 1).

Şekil 1 - Ana işlevin parametreleri

Programı yeni çalıştırdığımız ve ona herhangi bir argüman iletmediğimiz için Argüman değil mesajı belirdi. Şekil 2, aynı programın komut satırı üzerinden başlatıldığını, ancak kendisine Açık argümanın iletildiğini gösterir.

Şekil 2 - Ana işlevin parametreleri

Argüman Open kelimesidir, şekilden de görebileceğiniz gibi, bu kelime ekranda belirdi. Birden fazla parametreyi virgülle ayırarak aynı anda iletebilirsiniz. Birkaç kelimeden oluşan bir parametrenin iletilmesi gerekiyorsa, bunlar çift tırnak içine alınmalıdır ve bu kelimeler bir parametre olarak kabul edilecektir. Örneğin, şekil programın başlatılmasını gösterir ve ona iki kelimeden oluşan bir argümanı iletir - Çalışır .

Şekil 3 - Ana işlevin parametreleri

Ve eğer tırnakları kaldırırsanız. O zaman sadece O kelimesini göreceğiz. Programı başlatırken herhangi bir bilgi iletmeyi düşünmüyorsanız, o zaman main() fonksiyonundaki argümanları kaldırabilir, bu argümanların isimlerini de değiştirebilirsiniz. Bazen argc ve argv parametrelerinde değişiklikler olabilir, ancak bunların tümü oluşturulan uygulamanın türüne veya geliştirme ortamına bağlıdır.

C++ programlama dilinde otomatik olarak bir konsol uygulaması oluştururken, buna çok benzeyen bir ana işlev otomatik olarak oluşturulur:

int ana(int argc, karakter * argv)
{…}

İşlev başlığı, argc ve argv argümanlarıyla main() ana işlevinin imzasını içerir.
Program komut satırı üzerinden çalıştırılırsa, herhangi bir bilgiyi bu programa aktarmak mümkündür. Bunun için argc ve argv komut satırı argümanları vardır.
argc parametresi int türündedir ve ana işleve iletilen parametre sayısını içerir. Ayrıca, uygulamanın adı ilk parametre olarak kabul edildiğinden, ana işleve hiçbir bilgi aktarılmadığında bile argc her zaman en az 1'dir.
argv parametresi, dizelere yönelik bir işaretçi dizisidir. Komut satırından yalnızca dize türü veriler geçirilebilir.

Windows komut satırı üzerinden bir program çalıştırdığınızda, ona bazı bilgiler aktarabilirsiniz. Bu durumda komut satırı şöyle görünecektir:
Sürücü:\yol\ad.exe bağımsız değişken1 bağımsız değişken2 ...

Komut satırı bağımsız değişkenleri bir veya daha fazla boşlukla ayrılır.

argv bağımsız değişkeni, tam nitelikli uygulama adını içerir:

#Dahil etmek
ad alanı std kullanarak;

cout<< argv << endl;

0 döndür;
}

Yürütme sonucu

Örnek : iki tamsayının çarpımını hesaplamak
Program, StrToInt() işlevini buradan tamsayıya dönüştürmek için dizeyi kullanır.

#Dahil etmek
ad alanı std kullanarak;
int StrToInt(char*s) (…)
int main(int argc, char * argv) (

Int a = 0, b=0;

Eğer (argc > 1) ise

a = StrToInt(argv);

Eğer (argc > 2)

b = StrToInt(argv);

cout<< a <<«*» << b << «= « << a*b << endl;

0 döndür;
}

Program şu şekilde başlatılır:

Yürütme sonucu

Komut Satırı Bağımsız Değişkenleriyle Bir Programda Hata Ayıklama

Bir programda hata ayıklarken komut satırı argümanlarını iletmek için menüye erişmeniz gerekir. Özellikleri proje.


sekmesinde Yapılandırma Özellikleri ->Hata Ayıklama Seç Komut argümanları ve değerlerini ayarlayın.

Programı hata ayıklama modunda çalıştırdığınızda, girilen argümanlar program tarafından komut satırı argümanları olarak değerlendirilir.

Belirli argümanları C programlarına iletebilirsiniz. Main() hesaplamanın başında çağrıldığında, ona üç parametre iletilir. Bunlardan ilki, programa erişirken komut argümanlarının sayısını belirler. İkincisi, bu argümanları içeren karakter dizilerine yönelik bir işaretçi dizisidir (dize başına bir argüman). Üçüncüsü ayrıca karakter dizilerine yönelik bir dizi işaretçidir, işletim sistemi parametrelerine (ortam değişkenleri) erişmek için kullanılır.

Bu tür herhangi bir satır şu şekilde temsil edilir:

değişken = değer\0

Son satır, sondaki iki sıfır ile bulunabilir.

Main() işlevinin bağımsız değişkenlerini sırasıyla adlandıralım: argc, argv ve env (başka adlar da mümkündür). Ardından aşağıdaki açıklamalara izin verilir:

main(int argc, char *argv)

main(int argc, char *argv, char *env)

A: sürücüsünde bir program prog.exe olduğunu varsayalım. Bunu şöyle ele alalım:

A:\>prog.exe dosya1 dosya2 dosya3

Ardından argv, A:\prog.exe dizesinin bir göstergesidir, argv, dosya1 dizesinin bir göstergesidir ve bu böyle devam eder. İlk gerçek argümana argv ve son argümana argv ile işaret edilir. argc=1 ise, komut satırında program adından sonra parametre yoktur. Örneğimizde, argc=4.

özyineleme

Özyineleme, bir işlevin kendisini çağırdığı bir arama yöntemidir.

Özyinelemeli bir programın derlenmesinde önemli bir nokta, çıkışın organizasyonudur. Burada fonksiyonun sürekli olarak kendisini süresiz olarak çağıracağı hatasını yapmak kolaydır. Bu nedenle, özyinelemeli süreç, adım adım sorunu basitleştirmelidir, böylece sonunda özyinelemeli olmayan bir çözüm ortaya çıkar. Yığın taşmasına yol açabileceğinden özyineleme kullanmak her zaman istenmez.

Kütüphane Fonksiyonları

Programlama sistemlerinde, ortak sorunları çözmek için alt programlar kitaplıklarda birleştirilir. Bu görevler şunları içerir: matematiksel fonksiyonların hesaplanması, veri girişi/çıkışı, dizi işleme, işletim sistemi araçlarıyla etkileşim, vb. Kütüphane rutinlerinin kullanımı, kullanıcıyı uygun araçlar geliştirme ihtiyacından kurtarır ve ona ek bir hizmet sağlar. Kütüphanelerde bulunan fonksiyonlar programlama sistemi ile birlikte sağlanır. Bildirimleri *.h dosyalarında verilmiştir (bunlar sözde içerme veya başlık dosyalarıdır). Bu nedenle yukarıda da bahsedildiği gibi kütüphane fonksiyonlarına sahip programın başında aşağıdaki gibi satırlar bulunmalıdır:

#Dahil etmek<включаемый_файл_типа_h>

Örneğin:

#Dahil etmek

Kullanıcı programları ile yeni kitaplıkları genişletmek ve oluşturmak için olanaklar da vardır.

Global değişkenler, program süresince bellekte sabit bir yere atanır. Yerel değişkenler yığında saklanır. Aralarında dinamik ayırma için bir bellek alanı bulunur.

malloc() ve free() işlevleri, boş belleği dinamik olarak ayırmak için kullanılır. malloc() işlevi belleği ayırır, free() işlevi onu serbest bırakır. Bu işlevlerin prototipleri stdlib.h başlık dosyasında saklanır ve şöyle görünür:

void *malloc(size_t boyut);

void *serbest(void *p);

malloc() işlevi, void türünde bir işaretçi döndürür; doğru kullanım için, işlev değeri uygun türe bir işaretçiye dönüştürülmelidir. Başarı durumunda, işlev, boyut boyutundaki boş belleğin ilk baytına bir işaretçi döndürür. Yeterli bellek yoksa 0 döndürülür.sizeof() işlemi bir değişken için gereken bayt sayısını belirlemek için kullanılır.

Bu işlevlerin kullanımına bir örnek:

#Dahil etmek

#Dahil etmek

p = (int *) malloc(100 * sizeof(int)); /* 100 için bellek ayır

tam sayılar */

printf("Bellek yetersiz\n");

için (i = 0; ben< 100; ++i) *(p+i) = i; /* Использование памяти */

için (i = 0; ben< 100; ++i) printf("%d", *(p++));

ücretsiz(p); /* Boş hafıza */

malloc() tarafından döndürülen işaretçiyi kullanmadan önce, yeterli bellek olduğundan emin olmanız gerekir (işaretçi boş değil).

önişlemci

Bir C önişlemcisi, bir derleyiciye girdi işleyen bir programdır. Önişlemci kaynak programa bakar ve aşağıdaki eylemleri gerçekleştirir: verilen dosyaları ona bağlar, ikameleri gerçekleştirir ve ayrıca derleme koşullarını yönetir. Önişlemci, # sembolü ile başlayan program satırları için tasarlanmıştır. Satır başına yalnızca bir komuta (önişlemci yönergesi) izin verilir.

Direktif

#define tanımlayıcı değiştirme

aşağıdaki program metninin adlandırılmış tanımlayıcıyı ikame metniyle değiştirmesine neden olur (bu komutun sonunda noktalı virgül bulunmadığına dikkat edin). Esasen, bu yönerge bir makro tanımı (makro) sunar; burada "tanımlayıcı" makro tanımının adıdır ve "ikame" önişlemcinin belirtilen adı program metninde bulduğunda değiştirdiği karakter dizisidir. Bir makronun adı genellikle büyük harfle yazılır.

Örnekleri düşünün:

İlk satır, programın MAX tanımlayıcısını 25 sabitiyle değiştirmesine neden olur. İkinci satır, metinde açılış kaşlı ayracı (() BEGIN.

Önişlemci, makro tanımlarının sembolik adları ile bunların kullanıldığı bağlam arasındaki uyumluluğu kontrol etmediğinden, bu tür tanımlayıcıların #define yönergesi ile değil, açık bir türe sahip const anahtar sözcüğü ile tanımlanması önerilir. gösterge (bu, C + + için daha doğrudur):

const int MAX = 25;

(varsayılan olarak ayarlandığı için int türü atlanabilir).

#define yönergesi şuna benziyorsa:

#define tanımlayıcı(tanımlayıcı, ..., tanımlayıcı) ​​değiştirme

ve ilk tanımlayıcı ile açılış parantezi arasında boşluk yoksa, bu argümanlarla birlikte bir makro ikame tanımıdır. Örneğin, aşağıdaki gibi bir çizginin ortaya çıkmasından sonra:

#define READ(val) scanf("%d", &val)

ifade READ(y); scanf("%d",&y); ile aynı işlem yapılır. Burada val bir argümandır ve argümanla birlikte makro değiştirme gerçekleştirilir.

Bir sonraki satırda devam eden ikamede uzun tanımlar varsa, bir sonraki devam eden satırın sonuna bir \ karakteri yerleştirilir.

Bir makro tanımına ## karakterleriyle ayrılmış nesneleri yerleştirebilirsiniz, örneğin:

#define PR(x, y) x##y

Bundan sonra, PR(a, 3) ikameyi a3 olarak adlandıracaktır. Veya örneğin bir makro tanımı

#define z(a, b, c, d) a(b##c##d)

z(sin, x, +, y)'yi sin(x+y) olarak değiştirecektir.

Bir makro bağımsız değişkeninin önüne yerleştirilen # karakteri, bunun bir dizeye dönüştürüldüğünü gösterir. Örneğin, yönergeden sonra

#define PRIM(var) printf(#var"= %d", var)

program metninin aşağıdaki parçası

şu şekilde dönüştürülür:

printf("yıl""= %d", yıl);

Diğer önişlemci yönergelerini tanımlayalım. #include yönergesi daha önce görüldü. İki şekilde kullanılabilir:

#include "dosya adı"

#Dahil etmek<имя файла>

Her iki komutun da etkisi, programa belirtilen ada sahip dosyaları dahil etmektir. İlki, geçerli dizinden veya önek olarak belirtilen dizinden bir dosya yükler. İkinci komut, dosyayı programlama sisteminde tanımlanan standart konumlarda arar. Adı çift tırnak içinde yazılan dosya belirtilen dizinde bulunamazsa, arama #include komutu için belirtilen alt dizinlerde devam eder.<...>. #include yönergeleri iç içe yerleştirilebilir.

Bir sonraki yönerge grubu, programın bölümlerini seçici olarak derlemenize izin verir. Bu işleme koşullu derleme denir. Bu grup #if, #else, #elif, #endif, #ifdef, #ifndef yönergelerini içerir. #if yönergesinin temel biçimi şöyledir:

#if sabit_ifade ifadesi_dizisi

Burada sabit ifadenin değeri kontrol edilir. Doğruysa, verilen ifade dizisi yürütülür ve yanlışsa, bu ifade dizisi atlanır.

#else yönergesinin eylemi, C dilindeki else komutunun eylemine benzer, örneğin:

#if sabit_ifade

deyim_sekansı_2

Burada, sabit ifadesi true ise, o zaman sequence_of_operators_1 yürütülür ve eğer false ise, sequence_of_operators_2 yürütülür.

#elif yönergesi "else if" türünde bir eylem anlamına gelir. Kullanımının ana şekli aşağıdaki gibidir:

#if sabit_ifade

deyim_dizisi

#elif sabit_ifade_1

deyim_sequence_1

#elif sabit_ifade_n

sıra_ifadeler_n

Bu form, formun C dili yapısına benzer: if...else if...else if...

Direktif

#ifdef tanımlayıcısı

belirtilen tanımlayıcının şu anda tanımlı olup olmadığını ayarlar, yani. #define formunun direktiflerine dahil edilip edilmediği. Çizgiyi görüntüle

#ifndef tanımlayıcısı

belirtilen tanımlayıcının şu anda tanımsız olup olmadığını kontrol eder. Bu yönergelerden herhangi birini, muhtemelen bir #else ifadesi (#elif kullanılamaz) içeren ve #endif satırıyla biten rastgele sayıda metin satırı izleyebilir. Kontrol edilen koşul doğruysa, #else ile #endif arasındaki tüm satırlar yok sayılır ve yanlışsa, kontrol ile #else arasındaki satırlar (#else kelimesi yoksa, #endif) yok sayılır. #if ve #ifndef yönergeleri iç içe yerleştirilebilir.

Yönergeyi görüntüle

#undef tanımlayıcı

belirtilen tanımlayıcının tanımsız olarak değerlendirilmesine neden olur, yani. değiştirilemez.

Örnekleri düşünün. Üç direktif şunlardır:

WRITE tanımlayıcısının tanımlı olup olmadığını kontrol edin (yani #define WRITE... biçiminde bir komuttu) ve eğer öyleyse, WRITE adı tanımsız olarak kabul edilir, yani. değiştirilemez.

direktifler

#define WRITE fprintf

WRITE tanımlayıcısının tanımsız olup olmadığını kontrol edin ve eğer öyleyse, fprintf adı yerine WRITE tanımlayıcısı belirlenir.

#error yönergesi aşağıdaki biçimde yazılmıştır:

#error error_message

Program metninde oluşursa, derleme durur ve ekranda bir hata mesajı görüntülenir. Bu komut çoğunlukla hata ayıklama aşamasında kullanılır. Hata mesajının çift tırnak içine alınması gerekmediğini unutmayın.

#line yönergesi, C programlama sisteminde tanımlanan _LINE_ ve _FILE_ değişkenlerinin değerlerini değiştirmeye yöneliktir. _LINE_ değişkeni, yürütülmekte olan programın satır numarasını içerir. _FILE_ tanımlayıcısı, derlenmekte olan programın adını içeren bir dizeye işaretçidir. #line yönergesi şu şekilde yazılır:

#satır numarası "dosya adı"

Burada sayı, _LINE_ değişkenine atanacak herhangi bir pozitif tamsayıdır, dosya adı, _FILE_ değerini geçersiz kılan isteğe bağlı bir parametredir.

#pragma yönergesi derleyiciye bazı yönergeleri iletmenizi sağlar. Örneğin, çizgi

bir C programında derleme dili dizeleri olduğunu gösterir. Örneğin:

Bazı genel tanımlayıcıları veya makro adlarını (makro tanımlarının adları) göz önünde bulundurun. Bu tür beş ad tanımlanmıştır: _LINE_, _FILE_, _DATE_, _TIME_, _STDC_. Bunlardan ikisi (_LINE_ ve _FILE_) yukarıda zaten açıklanmıştır. _DATE_ tanımlayıcısı, kaynak dosyanın nesne koduna çevrildiği tarihi saklayan bir dize belirtir. _TIME_ tanımlayıcısı, kaynak dosyanın nesne koduna çevrildiği zamanı depolayan bir dize belirtir. Standart tanımlı makro adları kullanılıyorsa, _STDC_ makrosu 1 değerine sahiptir. Aksi takdirde bu değişken tanımlanmayacaktır.

Veriler, çağrıldığında komut satırından programa aktarılır. Bu tür verilere komut satırı argümanları denir. Şuna benziyor, örneğin:

./a.out test.txt ls -lt /home/peter/

Bu, a.out (geçerli dizinden) ve ls (PATH ortam değişkeninde belirtilen aynı dizinden) programlarını çağırır. Komut satırından ilk program bir kelime alır - test.txt, ikincisi - iki: -lt ve /home/peter/.

Program C ile yazılmışsa, başladığında kontrol hemen main() işlevine aktarılır, bu nedenle değişken parametrelerine atanan komut satırı argümanlarını alan odur.

Buraya kadar main() fonksiyonunu hiç parametre almıyor ve hiçbir şey döndürmüyormuş gibi tanımladık. Aslında, C'de varsayılan olarak herhangi bir işlev (başka hiçbir şey tanımlanmamışsa) bir tamsayı döndürür. Bu doğrulanabilir. Kodu şöyle yazarsanız:

main() ( printf("Merhaba \n") ; 0 döndür; )

Daha sonra derleme sırasında herhangi bir uyarı veya hata oluşmayacaktır. Aynısı int main() yazarsak da olur. Bu, varsayılan işlevin hiçbir şey (void) değil bir tamsayı döndürdüğünü kanıtlar. Her ne kadar işlevin döndürdüğü şey her zaman "geçersiz kılınabilir" olsa da, örneğin voidmain() veya float main() .

Komut satırından bir program çağrıldığında, ona her zaman bir çift veri iletilir:

1. tam sayı, çağrıldığında komut satırındaki sözcük sayısını (boşluklarla ayrılmış öğeler) belirtir,
2. dize dizisine işaretçi, burada her satır komut satırından tek bir kelimedir.

Program adının kendisinin de dikkate alındığını unutmayın. Örneğin, çağrı şöyle görünüyorsa:

./a.out 12 tema 2

Daha sonra programın ilk argümanı 4'tür ve string dizisi ("./a.out", "12", "theme", "2") olarak tanımlanır.

Terminolojiye dikkat edin, yalnızca iki program argümanı vardır (bir sayı ve bir dizi), ancak istediğiniz kadar komut satırı argümanı vardır. Komut satırı argümanları program argümanlarına "çevrilir" (main() fonksiyonunun argümanlarına).
Bu veriler (sayı ve işaretçi), programa herhangi bir şey iletilmeden sadece adıyla çağrıldığında bile iletilir: ./a.out. Bu durumda, ilk bağımsız değişken 1'dir ve ikinci bağımsız değişken yalnızca bir dizeden (""./a.out") oluşan bir diziye işaret eder.

Verilerin programa iletilmesi, main() fonksiyonunun onu alması gerektiği anlamına gelmez. main() işlevi parametreler olmadan tanımlanırsa, komut satırı argümanlarına erişilemez. Hiçbir şey onları göndermenizi engellemese de. Herhangi bir hata oluşmayacaktır.

Programa iletilen verilere erişmek için değişkenlere atanmaları gerekir. Argümanlar hemen main() öğesine iletildiğinden, başlığı şöyle görünmelidir:
ana (int n, karakter *dizi)

İlk değişken (n), sözcük sayısını içerir ve ikinci değişken, bir dizi diziye bir işaretçi içerir. Genellikle ikinci parametre **arr olarak yazılır. Ancak, aynıdır. Dize dizisinin kendisinin, öğeleri olarak dizelere işaretçiler içerdiğini hatırlayın. Ve fonksiyonda dizinin ilk elemanına bir işaretçi iletiyoruz. Bir işaretçiyi bir işaretçiye geçirdiğimiz ortaya çıktı, yani. **var.

Egzersiz yapmak
Bunun gibi bir program yazın:

#Dahil etmek int main(int argc, karakter ** argv) ( int i; printf ("%d \n", argc); için (i= 0 ; ben< argc; i++ ) puts (argv[ i] ) ; }

Çağrıldığında komut satırındaki kelime sayısını ve her kelimeyi yeni bir satıra yazdırır. Komut satırı argümanları olmadan ve argümanlarla arayın.

Programda argc ve argv değişken parametrelerini kullandık. Sadece bu tür isimleri kullanmak gelenekseldir, ancak aslında herhangi bir şey olabilirler. Programlarınızın sadece sizin için değil, diğer programcılar için de daha anlaşılır olması için bu standarda bağlı kalmak daha iyidir.

Bir Programa Veri Aktarmanın Pratik Önemi

GNU/Linux komut satırı konusunda deneyiminiz varsa, çoğu komutun anahtarları ve argümanları olduğunu bilirsiniz. Örneğin, dizinlerin içeriğini görüntülerken, kopyalama, taşıma, komutun yürütüldüğü dosya sistemi nesneleri argüman olarak belirtilir. Uygulamasının özellikleri, anahtarlar kullanılarak belirlenir. Örneğin, komutta

Cp -r ../les_1 ../les_101

cp komutun adıdır, -r anahtardır ve ../les_1 ve ../les_101 komut bağımsız değişkenleridir.

Genel olarak, çoğu zaman, programlar başlatıldığında, program yürütme sürecinin dosya adresleri ve "değiştiricileri" (bunlar anahtarlardır) aktarılır.

Kullanıcı tarafından belirtilen dosyaları yazmak veya eklemek için komut satırında açan ve programın yürütülmesi sırasında kullanıcının klavyeden girdiği aynı bilgileri buraya yazan (ekleyen) bir program yazalım:

#Dahil etmek #Dahil etmek main (int argc, char ** argv) ( int i, ch; DOSYA * f[ 5 ] ; if (argc< 3 || argc >7) ( koyar ( "Geçersiz sayıda parametre") ; dönüş 1 ; ) if (strcmp (argv[ 1 ] , "-w" ) != 0 && strcmp (argv[ 1 ] , "-a" ) != 0 ) ( koyar ( "İlk parametre -w veya -a olabilir") ; dönüş 2 ; ) için (i= 0 ; ben< argc- 2 ; i++ ) { f[ i] = fopen (argv[ i+ 2 ] , argv[ 1 ] + 1 ) ; if (f[ i] == NULL) { printf ("%s dosyası açılamıyor\n ", argv[ i+ 2 ] ) ; dönüş 3 ; ) ) while ((ch = getchar () ) != EOF) for (i= 0 ; i< argc- 2 ; i++ ) putc (ch, f[ i] ) ; for (i= 0 ; i < argc- 2 ; i++ ) fclose (f[ i] ) ; return 0 ; }

Kod için açıklamalar:

1. Beş dosya işaretçisi dizisi oluşturulur. Bu nedenle, aynı anda beşten fazla dosya açılamaz. İlk dosyanın dosya işaretçisi f dizi öğesinde, ikincisi - f'de vb.
2. Komut satırı argümanlarının sayısı kontrol edilir. En az üç tane olmalı, çünkü. ilki programın adı, ikincisi dosya açma modu, üçüncüsü yazılacak ilk veya tek dosyadır. Program yalnızca beş dosya açmanıza izin verdiğinden, toplam komut satırı argümanı sayısı yediyi aşamaz. Bu nedenle, argüman sayısı 3'ten az veya 7'den fazlaysa, program sona erer, çünkü Döndürme ifadesi, kendisinden sonra daha fazla kod olsa bile işlevin çıkmasına neden olur. 0'a eşit olmayan bir işlev dönüş değeri, ana işlem tarafından programın bir hatayla sonlandırıldığına dair bir mesaj olarak yorumlanabilir.
3. İkinci komut satırı argümanının doğruluğu kontrol edilir. "-w" veya "-a" değilse, ikinci if'deki koşullu ifade 1 (true) döndürür. strcmp() işlevi, dizeleri karşılaştırmanıza izin verir ve eşitlerse 0 döndürür.
4. for döngüsü, argv dizisinin üçüncü öğesinden başlayan belirtilen adreslerdeki dosyaları açar. Bu nedenle, argv dizisinin öğelerini almak için i'ye üçüncüden başlayarak 2 eklenir. argc-2 ifadesi, geçirilen dosya adlarının sayısını belirtir; çünkü argc, ilk ikisi dosya adı olmayan toplam komut satırı bağımsız değişkeni sayısını depolar.
5. argv+1 ifadesi, "w" (veya "a") alt dizesini "-w" (veya "-a") dizesinden "kesmenizi" sağlar, çünkü argv, esasen dizenin ilk öğesinin bir göstergesidir. İşaretçiye bir tane ekleyerek onu dizideki bir sonraki öğeye kaydırıyoruz.
6. Dosya açılamıyorsa, fopen() işlevi NULL değerini döndürür. Bu durumda program sona erer.
7. Kullanıcının klavyeden girdiği her karakter tüm açık dosyalara yazılır.
8. Sonunda dosyalar kapatılır.