- argc, un număr întreg, este numărul de argumente ale liniei de comandă trimise către funcția principală, - argv este o matrice de pointeri către șiruri de caractere (char *).

Tratez întotdeauna funcțiile C ca și cum ar fixa numărul de argumente indiferent de context, cu excepția cazului în care folosesc va_args. Adică cred că au ÎNTOTDEAUNA un prototip:

Int main(int argc, char **argv).

chiar dacă nu sunt transmise argumente, funcția are acele argumente în stivă, deoarece funcția principală nu are supraîncărcare a funcției.

C are capacitatea de a avea o supraîncărcare primitivă pretinzând pur și simplu că argumentul lipsește. În acest caz, argumentul este încă transmis și este pe stivă, dar nu îl accesați niciodată, așa că doar reduce dimensiunea codului sursă.

A spune int main() înseamnă pur și simplu că știu că funcția poate avea parametri, dar nu îi folosesc, așa că scriu int main().

Declarația int main (void) spune că main SCENELY nu are argumente și implică că există două prototipuri diferite de funcție:

Int main(void); int main(int argc, char **argv);

Deoarece C nu are o funcție de supraîncărcare, acest lucru este oarecum înșelător pentru mine și nu am încredere în codul cu un gol în el. Nu aș face decât dacă main nu a acceptat NICIODATĂ niciun parametru, caz în care main(void) ar fi complet bine.

NOTA. Unele implementări au mai mulți parametri în principal decât argc și argv ca env, dar asta nu mă deranjează pentru că știu că nu spun direct că aceștia sunt doar doi parametri, dar aceștia sunt parametrii minimi și totul este în regulă să ai mai mult, dar nu mai puțin. Acest lucru contrazice declarația directă a lui int main(void) care țipă la mine deoarece ACEASTA FUNCȚIE NU ARE PARAMETRI, ceea ce nu este adevărat, deoarece este, pur și simplu sunt omise.

Iată codul meu de bază:

/* sample.c - construiți în eșantion. */ #include int main(void) ( int _argc = *((int *)2686800); char ***_pargv = (char ***)2686804; int i; for (i = 1; i< _argc; ++i) { printf("%s ", (*_pargv)[i]); } return 0; }

./sample Am clar argumente

Funcția are în mod clar argumente transmise, chiar dacă nu spune în mod explicit că nu introduce void în prototipul funcției.

După cum s-a menționat mai sus:

(6.7.6.3p10) Un caz special al unui parametru nenumit de tip void de îndată ce un element din listă indică faptul că funcția nu are parametri.

Deci, a spune că o funcție are void ca argument, dar de fapt a avea argumente pe stivă este o contradicție.

Ideea mea este că argumentele încă există, așa că a spune în mod explicit că principalul nu conține argumente este necinstit. O modalitate corectă ar fi să spunem int main(), care nu afirmă nimic despre câți parametri are, ci doar de câți parametri aveți nevoie.

NOTĂ 2: _argc, _pargv sunt dependente de sistem pentru a găsi valorile pe care ar trebui să le găsiți rulând acest program:

/* findargs.c */ #include int main(int argc, char **argv) ( printf("adresa argc este %u.\n", &argc); printf("adresa argv este %u.\n", &argv); return 0; )

Aceste valori ar trebui să rămână corecte pentru sistemul dumneavoastră specific.

Borland C++ acceptă trei argumente pentru main(). Primele două sunt tradiționalele argc și argv. Acestea sunt singurele argumente pentru main() definite de standardul ANSI C. Ele permit transmiterea argumentelor din linia de comandă către program. Argumentele liniei de comandă sunt informațiile care urmează numele programului pe linia de comandă a sistemului de operare. De exemplu, atunci când un program este compilat folosind compilatorul de linie Borland, acesta este de obicei tastat bcc nume_program

Unde nume_program este un program care trebuie compilat. Numele programului este transmis compilatorului ca argument.

Parametrul argc conține numărul de argumente ale liniei de comandă și este un număr întreg. Este întotdeauna egal cu cel puțin 1, deoarece numele programului se califică drept primul argument. Parametrul argv este un pointer către o matrice de pointeri de caractere. Fiecare element al acestui tablou indică un argument de linie de comandă. Toate argumentele liniei de comandă sunt șiruri. Toate numerele sunt convertite de program în format intern. Următorul program afișează „Bună ziua” urmat de numele de utilizator când este introdus direct după numele programului:

#include

{
if(argc!=2)
{
printf("Ai uitat sa-ti introduci numele\n");
întoarcere 1;
}
printf("Bună ziua %s", argv);
returnează 0;
}

Dacă apelați numele acestui program și numele de utilizator este Sergey, atunci pentru a porni programul ar trebui să tastați:
numele Serghei.
Ca rezultat al programului, vor apărea următoarele:
— Bună, Serghei.

Argumentele liniei de comandă trebuie separate prin spații sau file. Virgulele, punctele și virgulă și caracterele similare nu sunt considerate delimitatori. De exemplu:

Constă din trei rânduri, în timp ce

Herb, Rick, Fred

Aceasta este o singură linie - virgulele nu sunt delimitătoare.

Dacă trebuie să treceți un șir care conține spații sau tab-uri ca un singur argument, trebuie să-l încadrați între ghilimele duble. De exemplu, acesta este un argument:

"acesta este un test"

Este important să declarați corect argv. Cea mai tipică metodă este:

Parantezele goale indică faptul că tabloul nu are o lungime fixă. Puteți accesa elemente individuale folosind indexarea argv. De exemplu, argv indică către prima linie, care conține întotdeauna numele programului. argv indică la următoarea linie și așa mai departe.

Mai jos este un mic exemplu de utilizare a argumentelor din linia de comandă. Numărătoarea inversă de la valoarea specificată pe linia de comandă și emite un semnal când ajunge la zero. Rețineți că primul argument conține un număr convertit într-un număr întreg folosind funcția standard atoi(). Dacă șirul „display” este prezent ca al doilea argument, atunci contorul însuși va fi afișat pe ecran.

/* program de numărare */

#include
#include
#include
int main(int argc, char *argv)
{
int disp, numărare;
dacă (argc<2)
{
printf("Trebuie să introduceți lungimea numărării\n");
printf("pe linia de comandă. Încercați din nou.\n");
întoarcere 1;
}
if (argc==3 && !strcmp(argv,"display")) disp = 1;
else disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d", count);
printf("%c", "\a"); /* pe majoritatea computerelor, acesta este un apel */
returnează 0;
}

Vă rugăm să rețineți că, dacă nu sunt specificate argumente, apare un mesaj de eroare. Acest lucru este cel mai tipic pentru programele care folosesc argumente de linie de comandă pentru a emite instrucțiuni dacă s-a încercat să ruleze programul fără informațiile corecte.

Pentru a accesa caractere individuale ale liniei de comandă, adăugați un al doilea index la argv. De exemplu, următorul program imprimă toate argumentele cu care a fost apelat, câte un caracter:

#include
int main(int argc, char *argv)
{
int t, i;
pentru(t=0; t {
i = 0;
în timp ce(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(" ");
}
returnează 0;
}

Trebuie să ne amintim că primul index este pentru accesarea unui șir, iar al doilea este pentru accesarea unui caracter dintr-un șir.

De obicei, argc și argv sunt folosite pentru a obține comenzi sursă. Teoretic este posibil să aveți până la 32767 de argumente, dar majoritatea sistemelor de operare nici măcar nu vă permit să vă apropiați de asta. De obicei, aceste argumente sunt folosite pentru a specifica un nume de fișier sau opțiuni. Utilizarea argumentelor din linia de comandă oferă programului un aspect profesional și permite programului să fie utilizat în fișiere batch.

Dacă includeți fișierul WILDARGS.OBJ furnizat cu Borland C++, puteți utiliza șabloane în argumente de tip *.EXE. (Borland C++ gestionează automat metacaracterele și incrementează argc în consecință.) De exemplu, dacă conectați WILDARGS.OBJ la următorul program, acesta vă va spune câte fișiere se potrivesc cu numele fișierului specificat în linia de comandă:

/* Conectați acest program cu WILDARGS.OBJ */

#include
int main(int argc, char *argv)
{
înregistrare int i;
printf("%d fișiere se potrivesc cu numele specificat\n", argc-1);
printf("Sunt: ");
pentru (i=1; i printf("%s", argv[i]);
returnează 0;
}

Dacă numim acest program WA, apoi îl rulăm după cum urmează, vom obține numărul de fișiere cu extensia EXE și o listă cu numele acestor fișiere:

Pe lângă argc și argv, Borland C++ oferă și un al treilea argument de linie de comandă -env. Parametrul env permite unui program să acceseze informații despre mediul sistemului de operare. Parametrul env trebuie să urmeze argc și argv și este declarat după cum urmează:

După cum puteți vedea, env este declarat în același mod ca argv. La fel ca argv, este un pointer către o matrice de șiruri. Fiecare linie este un șir de mediu definit de sistemul de operare. Parametrul env nu are un parametru argc echivalent care să spună câte rânduri de mediu există. În schimb, ultima linie a mediului este nulă. Următorul program imprimă toate șirurile de mediu definite în prezent în sistemul de operare:

/* acest program afișează toate liniile de mediu */

#include
int main(int argc, char *argv, char *env)
{
int;
for(t=0; env[t]/t++)
printf("%s\n", env[t]);
returnează 0;
}

Vă rugăm să rețineți că, deși argc și argv nu sunt folosite de program, ele trebuie să fie prezente în lista de parametri. C nu cunoaște numele parametrilor. În schimb, utilizarea lor este determinată de ordinea în care sunt declarați parametrii. De fapt, puteți apela parametrul cum doriți. Deoarece argc, argv și env sunt nume tradiționale, cel mai bine este să le folosiți în continuare, astfel încât oricine citește programul să poată înțelege instantaneu că acestea sunt argumente pentru funcția main().

O sarcină tipică pentru programe este să caute o valoare definită într-un șir de mediu. De exemplu, conținutul liniei PATH permite programelor să utilizeze căi de căutare. Următorul program demonstrează cum să găsiți șiruri de caractere care declară căi de căutare standard. Utilizează funcția standard de bibliotecă strstr(), care are următorul prototip:

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

Funcția strstr() caută șirul indicat de str1 în șirul indicat de str2. Dacă se găsește un astfel de șir, este returnat un pointer către prima poziție. Dacă nu se găsesc potriviri, funcția returnează NULL.

/* programul caută printre șirurile de mediu o linie care conține PATH */

#include
#include
int main (int argc, char *argv, char *env)
{
int;
pentru(t=0; env[t]; t++)
{
if(strstr(env[t], „CALEA”))
printf("%s\n", env[t]);
}
returnează 0;
}