Când se creează o aplicație consolă în limbajul de programare C++, se creează automat o linie foarte asemănătoare cu aceasta:

Int main(int argc, char* argv) // parametrii funcției main().

Această linie este antetul funcției principale main(), parametrii argс și argv sunt declarați între paranteze. Deci, dacă rulați un program prin linia de comandă, atunci este posibil să transferați unele informații în acest program, pentru aceasta există parametrii argc și argv. Parametrul argc are un tip de date int și conține numărul de parametri transmisi funcției principale. Mai mult, argc este întotdeauna cel puțin 1, chiar și atunci când nu transmitem nicio informație, deoarece primul parametru este numele funcției. Parametrul argv este o matrice de pointeri către șiruri. Prin linia de comandă pot fi transmise doar datele șir. Pointerii și șirurile sunt două subiecte mari pentru care au fost create secțiuni separate. Deci prin parametrul argv este transmisă orice informație. Să dezvoltăm un program pe care îl vom rula prin linia de comandă Windows și să îi transmitem câteva informații.

// argc_argv.cpp: Definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include folosind namespace std; int main(int argc, char* argv) (daca (argc ><< argv<

// cod Cod::Blocuri

// Cod Dev-C++

// argc_argv.cpp: Definește punctul de intrare pentru aplicația consolă. #include folosind namespace std; int main(int argc, char* argv) ( if (argc > 1) // dacă trecem argumente, atunci argc va fi mai mare decât 1 (în funcție de numărul de argumente) ( cout<< argv<

După ce am depanat programul, deschideți linia de comandă Windows și trageți fișierul executabil al programului nostru în fereastra liniei de comandă Calea completă către program va fi afișată în linia de comandă (dar puteți introduce calea către program manual ), după care puteți da clic ENTER iar programul va porni (vezi Figura 1).

Figura 1 - Parametrii principali ai funcției

Deoarece pur și simplu am rulat programul și nu i-am transmis niciun argument, a apărut mesajul Not arguments. Figura 2 arată lansarea aceluiași program prin linia de comandă, dar trecându-i argumentul Open.

Figura 2 - Parametrii principali ai funcției

Argumentul este cuvântul Open, după cum se vede din figură, acest cuvânt a apărut pe ecran. Puteți trece mai mulți parametri deodată, separându-i cu o virgulă. Dacă trebuie să treceți un parametru format din mai multe cuvinte, atunci acestea trebuie incluse între ghilimele duble, iar apoi aceste cuvinte vor fi considerate ca un parametru. De exemplu, figura arată lansarea unui program, trecându-i un argument format din două cuvinte - Funcționează.

Figura 3 - Parametrii principali ai funcției

Și dacă eliminați ghilimele. Atunci vom vedea doar cuvântul It. Dacă nu intenționați să transmiteți nicio informație atunci când rulați programul, puteți elimina argumentele din funcția main() și puteți modifica, de asemenea, numele acestor argumente. Uneori se întâlnesc modificări ale parametrilor argc și argv, dar totul depinde de tipul de aplicație creată sau de mediul de dezvoltare.

Uneori, atunci când porniți un program, este util să îi transmiteți câteva informații. De obicei, aceste informații sunt transmise la main() prin argumente din linia de comandă. Argumentul liniei de comandă sunt informații care sunt introduse pe linia de comandă a sistemului de operare după numele programului. De exemplu, pentru a începe compilarea unui program, trebuie să tastați ceva de genul următor pe linia de comandă după prompt:

Cc nume_program

nume_program este un argument de linie de comandă, specifică numele programului pe care urmează să-l compilați.

Pentru a accepta argumente din linia de comandă, sunt folosite două argumente speciale încorporate: argc și argv. Parametrul argc conține numărul de argumente de pe linia de comandă și este un număr întreg și este întotdeauna cel puțin 1, deoarece primul argument este numele programului. Iar parametrul argv este un pointer către o matrice de pointeri către șiruri. În această matrice, fiecare element indică un argument de linie de comandă. Toate argumentele liniei de comandă sunt șiruri de caractere, așa că conversia oricăror numere în formatul binar dorit trebuie să fie furnizată în program atunci când este dezvoltat.

Iată un exemplu simplu de utilizare a unui argument de linie de comandă. Cuvântul Bună ziua și numele dvs. sunt afișate pe ecran, care trebuie specificate ca argument în linia de comandă.

#include #include int main(int argc, char *argv) ( if(argc!=2) ( printf("Ați uitat să vă introduceți numele.\n"); exit(1); ) printf("Bună ziua %s", argv) ; întoarcere 0;

Dacă ați numit acest program numele (nume) și numele dvs. este Tom, atunci pentru a rula programul ar trebui să introduceți numele Tom în linia de comandă. Ca urmare a executării programului, pe ecran va apărea mesajul Hello, Tom.

În multe medii, toate argumentele liniei de comandă trebuie separate printr-un spațiu sau tab. Virgulele, punctele și virgulă și caracterele similare nu sunt considerate delimitatori. De exemplu,

Aleargă Spot, alergă

constă din trei șiruri de caractere, în timp ce

Eric, Rick, Fred

reprezintă un singur șir de caractere - virgulele, de regulă, nu sunt considerate delimitatori.

Dacă un șir conține spații, puteți include șirul între ghilimele duble în unele medii pentru a preveni producerea mai multor argumente. Ca rezultat, întregul șir va fi considerat un argument. Pentru a afla mai multe despre modul în care sistemul de operare specifică parametrii liniei de comandă, consultați documentația sistemului de operare.

Este foarte important să declarați corect argv. Iată cum se face cel mai des:

Char *argv;

Parantezele pătrate goale indică faptul că matricea are o lungime nedefinită. Argumentele individuale pot fi acum accesate prin indexarea matricei argv. De exemplu, argv indică primul șir de caractere, care este întotdeauna numele programului; argv indică primul argument și așa mai departe.

Un alt exemplu mic de utilizare a argumentelor liniei de comandă este următorul program, numărătoarea inversă. Acest program numără înapoi, pornind de la o valoare (specificată pe linia de comandă) și emite un bip când ajunge la 0. Rețineți că primul argument, care conține valoarea de pornire, este convertit într-o valoare întreagă folosind funcția standard atoi (). Dacă al doilea argument din linia de comandă (și dacă considerăm numele programului ca un argument, atunci al treilea) este linia „display” (afișare), atunci rezultatul numărării (în ordine inversă) va fi afișat pe ecran.

/* Program de numărare în ordine inversă. */ #include #include #include #include int main(int argc, char *argv) ( int disp, count; if(argc)<2) { printf("В командной строке необходимо ввести число, с которого\n"); printf("начинается отсчет. Попробуйте снова.\n"); exit(1); } if(argc==3 && !strcmp(argv, "display")) disp = 1; else disp = 0; for(count=atoi(argv); count; --count) if(disp) printf("%d\n", count); putchar("\a"); /* здесь подается звуковой сигнал */ printf("Счет закончен"); return 0; }

Vă rugăm să rețineți că dacă argumentele liniei de comandă nu sunt specificate, va fi afișat un mesaj de eroare. Programele care preiau argumente în linia de comandă fac adesea următoarele: Când utilizatorul rulează aceste programe fără a introduce informațiile necesare, ele afișează instrucțiuni despre cum să specifice corect argumentele.

Pentru a accesa un caracter individual al unuia dintre argumentele liniei de comandă, introduceți un al doilea index în argv. De exemplu, următorul program imprimă, caracter cu caracter, toate argumentele cu care a fost apelat:

#include int main(int argc, char *argv) ( int t, i; for(t=0; t

Amintiți-vă, primul index al lui argv oferă acces la șir, iar al doilea index oferă acces la caracterele sale individuale.

În mod obișnuit, argc și argv sunt folosite pentru a oferi programului comenzile inițiale de care va avea nevoie atunci când pornește. De exemplu, argumentele liniei de comandă specifică adesea informații precum un nume de fișier, o opțiune sau un comportament alternativ. Utilizarea argumentelor din linia de comandă oferă programului dumneavoastră un „aspect profesional” și îl face mai ușor de utilizat în fișierele batch.

Numele argc și argv sunt tradiționale, dar nu sunt obligatorii. Puteți apela acești doi parametri în funcția main() orice doriți. În plus, unele compilatoare pot accepta argumente suplimentare pentru main(), așa că asigurați-vă că verificați documentația compilatorului.

Când un program nu necesită parametrii de linie de comandă, este cel mai frecvent să se declare explicit funcția main() ca neavând parametri. În acest caz, cuvântul cheie void este utilizat în lista de parametri a acestei funcții.

Etichete: Opțiuni pentru linia de comandă

Opțiuni pentru linia de comandă

C este un limbaj compilat. După asamblare, programul este un fișier executabil (nu avem în vedere crearea de biblioteci dinamice, drivere etc.). Programele noastre sunt foarte simple și nu conțin biblioteci Runtime, așa că pot fi transferate pe un computer cu același sistem de operare (și arhitectură similară) și rulate acolo.

Programul poate accepta parametri în timpul pornirii. Sunt argumente pentru funcția principală. Vederea generală a funcției principale este următoarea

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

Primul argument al argc este numărul de parametri trecuți funcției. Al doilea argument este o matrice de șiruri de caractere – parametrii înșiși. Deoarece parametrii unei funcții pot fi orice, ei sunt transmisi ca șiruri de caractere, iar programul însuși trebuie să-i analizeze și să-i convertească în tipul dorit.

Primul argument (argv) este întotdeauna numele programului. În acest caz, numele este afișat în funcție de locul de unde a fost lansat programul.

#include #include void main(int argc, char **argv) ( printf("%s", argv); )

Acum să învățăm cum să lucrăm puțin cu linia de comandă. Acest lucru va fi necesar pentru a transmite argumente programului nostru. Combinația de taste Win+R afișează fereastra Run. Tastați cmd în el și veți deschide linia de comandă. De asemenea, puteți găsi cmd.exe căutând în meniul Start. În sistemele de operare asemănătoare Unix, puteți apela programul terminal.

Nu vom învăța prea multe comenzi. Doar cele necesare pentru muncă.

Comanda cd, standard pentru toate sistemele de operare, navighează la folderul dorit. Există două nume rezervate - . (punct) și.. (două puncte). Punctul este numele folderului curent.

Nu merge nicăieri

Accesarea folderului părinte

Accesați folderul părinte

Pentru a merge la cea dorită, scrieți adresa CD-ului. De exemplu, trebuie să accesați Windows în folderul C:\Windows\System32

Cd C:\Windows\System32

În Linux, dacă trebuie să accesați folderul /var/mysql

Cd /var/mysql

Dacă calea conține spații, se scrie între ghilimele duble

Cd „D:\Documente și setări\Prolog”

Terminalul are următoarele caracteristici utile: dacă apăsați săgeata sus, va apărea comanda executată anterior. Dacă apăsați tab, terminalul va încerca să completeze linia la o comandă cunoscută de acesta sau să completeze calea, parcurgând toate folderele și fișierele din folderul curent.
Tastați cd C:\
apăsați pe tab și vedeți ce se întâmplă.

O altă comandă importantă, dir pe Windows și ls pe Linux, afișează conținutul folderului curent (dosarul în care vă aflați în prezent) pe consolă.

Programul dvs. a returnat numele complet. Accesați folderul în care se află programul dvs. și uitați-vă la conținutul acestuia

Acum că am navigat la folderul nostru, putem rula programul nostru. Pentru a face acest lucru, introduceți numele ei.

Rețineți că numele s-a schimbat. Deoarece programul este apelat din propriul folder, este afișat numele relativ. Acum să schimbăm programul și să-l facem să imprime toate argumentele. care i-au fost dăruite.

#include #include void main(int argc, char **argv) ( int i; for (i = 0; i)< argc; i++) { printf("%s\n", argv[i]); } }

Asamblați proiectul. Înainte de asamblare, asigurați-vă că programul este închis. Acum apelați programul, trecându-i diferite argumente. Pentru a face acest lucru, scrieți numele programului și argumentele separate printr-un spațiu

Să scriem acum un program care ia două argumente numerice și le imprimă suma

#include #include #include void main(int argc, char **argv) ( int a, b; if (argc != 3) ( printf("Eroare: au găsit %d argumente. Necesită exact 2", argc-1); exit(1); ) a = atoi(argv); b = atoi(argv);

Să colectăm și să sunăm

Așa funcționează majoritatea programelor. Făcând clic pe o comandă rapidă, apelați programul la care se referă. Majoritatea programelor acceptă, de asemenea, diverse argumente. De exemplu, puteți apela browserul Firefox din linia de comandă și puteți transmite argumentele
firefox.exe „www.mozilla.org” „site” și va deschide imediat site-urile la adresele specificate în două file.

Multe comenzi standard au și parametri. În Windows este obișnuit ca acestea să înceapă cu o bară oblică, în Unix cu un minus sau două minusuri. De exemplu

Afișează doar folderele, dar în terminalul Linux

Ls -l listează toate fișierele și folderele cu atribute

Pentru a vizualiza comenzi suplimentare Windows, tastați ajutor în linia de comandă sau consultați manualul (este ușor de găsit pe Internet). Pentru Linux există mult mai multe comenzi și opțiunile lor, iar unele dintre ele sunt limbaje de programare independente, așa că merită să înveți cel puțin setul minim și opțiunile lor.

Într-o zi m-am interesat de conținutul stivei de funcție principală a unui proces în Linux. Am făcut câteva cercetări și acum vă prezint rezultatul.

Opțiuni pentru descrierea funcției principale:
1. int main()
2. int main(int argc, char **argv)
3. int main(int argc, char **argv, char **env)
4. int main(int argc, char **argv, char **env, ElfW(auxv_t) auxv)
5. int main(int argc, char **argv, char **env, char **apple)

Argc - numărul de parametri
argv - matrice null-terminal de pointeri către șirurile de parametri ale liniei de comandă
env este o matrice null-terminal de pointeri către șiruri de variabile de mediu. Fiecare linie în format NAME=VALUE
auxv - matrice de valori auxiliare (disponibil numai pentru PowerPC)
Apple - calea către fișierul executabil (pe MacOS și Darwin)
Un vector auxiliar este o matrice cu diverse informații suplimentare, cum ar fi identificatorul efectiv de utilizator, atributul de bit setuid, dimensiunea paginii de memorie etc.

Mărimea segmentului de stivă poate fi găsită în fișierul hărților:
cat /proc/10918/maps
…
7ffffffa3000-7ffffffff000 rw-p 00000000 00:00 0
…

Înainte ca încărcătorul să transfere controlul pe main, acesta inițializează conținutul matricelor de parametri ai liniei de comandă, variabilelor de mediu și vectorului auxiliar.
După inițializare, partea de sus a stivei arată cam așa pentru versiunea pe 64 de biți.
Adresa seniorului în partea de sus.

Nu am verificat pentru 32 de biți, dar cel mai probabil este suficient să împarți dimensiunile la doi.

1. Accesarea adreselor deasupra punctului superior cauzează o eroare Seg.
2. Un șir care conține calea către fișierul executabil.
3. Matrice de șiruri cu variabile de mediu
4. Matrice de șiruri de caractere cu parametrii de linie de comandă
5. Matrice de lungime aleatorie. Selectarea acestuia poate fi dezactivată cu ajutorul comenzilor
sysctl -w kernel.randomize_va_space=0
echo 0 > /proc/sys/kernel/randomize_va_space
6. Date pentru vectorul auxiliar (de exemplu, șirul „x86_64”)
7. Vector auxiliar. Mai multe detalii mai jos.
8. Matrice null-terminal de pointeri către șiruri de variabile de mediu
9. Matrice null-terminal de pointeri către șiruri de parametri ale liniei de comandă
10. Un cuvânt mașină care conține numărul de parametri ai liniei de comandă (unul dintre argumentele funcțiilor „majore”, vezi paragraful 11)
11. Variabile locale și argumente ale funcțiilor numite înainte de main(_start,__libc_start_main..)
12. Variabilele declarate în principal
13.Argumente ale funcției principale
14. Variabile și argumente ale funcțiilor locale.

Vector auxiliar
Pentru i386 și x86_64, nu este posibilă obținerea adresei primului element al vectorului auxiliar, dar conținutul acestui vector poate fi obținut în alte moduri. Una dintre ele este accesarea zonei de memorie imediat din spatele matricei de pointeri către șiruri de variabile de mediu.
Ar trebui să arate cam așa:
#include #include int main(int argc, char** argv, char** env)( Elf64_auxv_t *auxv; //x86_64 // Elf32_auxv_t *auxv; //i386 while(*env++ != NULL); //căutând începutul vector auxiliar pentru ( auxv = (Elf64_auxv_t *)env; auxv->a_type != AT_NULL; auxv++)( printf("addr: %p type: %lx is: 0x%lx\n", auxv, auxv->a_type, auxv->a_un .a_val ) printf("\n (void*)(*argv) - (void*)auxv= %p - %p = %ld\n (void*)(argv)-(void* )(&auxv) =%p-%p = %ld\n ", (void*)(*argv), (void*)auxv, (void*)(*argv) - (void*)auxv, (void* )(argv) , (void*)(&auxv), (void*)(argv) - (void*)(&auxv)); printf("\n argc copie: %d\n",*((int *)); (argv - 1)));
Structurile Elf(32,64)_auxv_t sunt descrise în /usr/include/elf.h. Funcții pentru umplerea structurilor în linux-kernel/fs/binfmt_elf.c

A doua modalitate de a obține conținutul unui vector:
hexdump /proc/self/auxv

Cea mai lizibilă reprezentare se obține prin setarea variabilei de mediu LD_SHOW_AUXV.

LD_SHOW_AUXV=1 ls
AT_HWCAP: bfebfbff //capacități procesor
AT_PAGESZ: 4096 //dimensiunea paginii de memorie
AT_CLKTCK: 100 //frecvența actualizării ori()
AT_PHDR: 0x400040 //informații din antet
AT_PHENT: 56
AT_PHNUM: 9
AT_BASE: 0x7fd00b5bc000 //adresa interpretului, adică ld.so
AT_FLAGS: 0x0
AT_ENTRY: 0x402490 //punct de intrare în program
AT_UID: 1000 //identificatori de utilizator și grup
AT_EUID: 1000 //nominal și efectiv
AT_GID: 1000
AT_EGID: 1000
AT_SECURE: 0 //dacă steagul setuid este ridicat
AT_RANDOM: 0x7fff30bdc809 //adresă de 16 octeți aleatori,
generate la pornire
AT_SYSINFO_EHDR: 0x7fff30bff000 //indicator către pagina folosită pentru
//apeluri de sistem
AT_EXECFN: /bin/ls
AT_PLATFORM: x86_64
În stânga este numele variabilei, în dreapta este valoarea. Toate numele variabilelor posibile și descrierile acestora pot fi găsite în fișierul elf.h. (constante cu prefixul AT_)

Întoarcere de la principal()
După ce contextul procesului este inițializat, controlul este transferat nu către main(), ci către funcția _start().
main() este deja apelată din __libc_start_main. Această ultimă funcție are o caracteristică interesantă - i se transmite un pointer către o funcție care ar trebui să fie executată după main(). Și acest indicator este trecut în mod natural prin stivă.
În general, argumentele pentru __libc_start_main arată astfel, conform fișierului glibc-2.11/sysdeps/ia64/elf/start.S
/*
* Argumente pentru __libc_start_main:
* out0: principal
* out1: argc
* out2: argv
* out3: init
* out4: fini //funcție numită după main
* out5: rtld_fini
* out6: stack_end
*/
Aceste. pentru a obține adresa indicatorului fini, trebuie să mutați două cuvinte mașină din ultima variabilă locală main.
Iată ce s-a întâmplat (funcționalitatea depinde de versiunea compilatorului):
#include void **ret; void *pleacă; void foo())( void (*boo)(void); //funcție pointer printf("Stiva rescrie!\n"); boo = (void (*)(void))leave; boo(); // fini () ) int main(int argc, char *argv, char *envp) (unsigned long int mark = 0xbfbfbfbfbfbfbfbf; //mark din care vom lucra ret = (void**)(&mark+2); // extrage adresa , funcția numită după completare (fini) leave = *ret // reține *ret = (void*)foo // return 0;

Sper că a fost interesant.
Noroc.

Mulțumim utilizatorului Xeor pentru sfatul util.

Se întâmplă ca datele să fie transferate într-un program din linia de comandă atunci când este apelat. Astfel de date se numesc argumente de linie de comandă. Arata cam asa, de exemplu:

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

Aici sunt apelate programele a.out (din directorul curent) și ls (din același director specificat în variabila de mediu PATH). Primul program din linia de comandă primește un cuvânt - test.txt, al doilea - două: -lt și /home/peter/.

Dacă programul este scris în C, atunci când este lansat, controlul este imediat transferat către funcția main(), prin urmare, este funcția care primește argumentele liniei de comandă care sunt alocate variabilelor sale de parametri.

Anterior, am definit funcția main() ca și cum nu ar lua niciun parametri și nu returnează nimic. De fapt, în limbajul C, orice funcție implicită (dacă nu este definit nimic altceva) returnează un număr întreg. Poți fi sigur de asta. Dacă scrieți codul astfel:

main() ( printf ("Bună \n");

returnează 0;

)

1. Atunci nu va apărea niciun avertisment sau eroare în timpul compilării. Același lucru se întâmplă dacă scrieți int main() . Acest lucru demonstrează că funcția returnează un întreg în mod implicit și nu nimic (void). Deși ceea ce returnează o funcție poate fi întotdeauna „supracris”, de exemplu, voidmain() sau float main() . Când apelați un program din linia de comandă, următoarea pereche de date este întotdeauna transmisă în el:
2. întreg, indicând numărul de cuvinte (elemente separate prin spații) pe linia de comandă atunci când sunt apelate,

pointer către o matrice de șiruri de caractere

, unde fiecare linie este un cuvânt separat de linia de comandă.

Rețineți că și numele programului contează. De exemplu, dacă apelul arată astfel:

./a.out 12 tema 2
Apoi primul argument al programului are valoarea 4, iar matricea de șiruri este definită ca ("./a.out", "12", "theme", "2").

Rețineți terminologia, există doar două argumente de program (un număr și o matrice), dar câte argumente de linie de comandă doriți. Argumentele liniei de comandă sunt „convertite” în argumente de program (în argumente ale funcției main()).

Pentru a accesa datele transmise programului, acestea trebuie alocate unor variabile. Deoarece argumentele sunt transmise imediat la main() , antetul acestuia ar trebui să arate astfel:
principal (int n, char *arr)

Prima variabilă (n) conține numărul de cuvinte, iar a doua variabilă conține un pointer către o matrice de șiruri. Adesea, al doilea parametru este scris ca **arr . Totuși, este același lucru. Reamintim că matricea de șiruri în sine conține pointeri către șiruri ca elemente. Și trecem un pointer către primul element al matricei funcției. Se pare că trecem un pointer către un pointer, adică. **arr.

Exercita
Scrie un program ca acesta:

#include int main(int argc, char ** argv) ( int i; printf ("%d \n", argc) ;< argc; i++ ) puts (argv[ i] ) ; }

pentru (i= 0; i

Afișează numărul de cuvinte de pe linia de comandă atunci când este apelat și fiecare cuvânt pe o linie nouă. Apelați-l fără argumente de linie de comandă și cu argumente.

În program am folosit variabilele parametrilor argc și argv. Se obișnuiește să se folosească aceste nume, dar de fapt pot fi orice. Este mai bine să respectați acest standard, astfel încât programele dvs. să fie mai înțelese nu numai pentru dvs., ci și pentru alți programatori.

Semnificația practică a transferului de date în program

Dacă aveți experiență cu linia de comandă GNU/Linux, știți că majoritatea comenzilor au comutatoare și argumente. De exemplu, la vizualizarea conținutului directoarelor, copierea, mutarea, obiectele sistemului de fișiere pe care este executată comanda sunt specificate ca argumente. Caracteristicile implementării sale sunt determinate folosind chei. De exemplu, într-o echipă

Cp -r ../les_1 ../les_101

cp este numele comenzii, -r este comutatorul și ../les_1 și ../les_101 sunt argumentele comenzii.

În general, cel mai adesea, adresele fișierelor și „modificatoarele” (acestea sunt chei) ale procesului de execuție a programului sunt transferate în programe atunci când sunt lansate.

#include Să scriem un program care deschide fișierele specificate de utilizator pe linia de comandă pentru scriere sau adăugare și scrie (adaugă) acolo aceleași informații pe care utilizatorul le introduce de la tastatură în timpul execuției programului: #include< 3 || argc >main (int argc, char ** argv) ( int i, ch; FILE * f[ 5 ] ; if (argc) 7) (pune („Număr nevalid de parametri” );întoarcere 1;< argc- 2 ; i++ ) { f[ i] = fopen (argv[ i+ 2 ] , argv[ 1 ] + 1 ) ; if (f[ i] == NULL) { printf () dacă (strcmp (argv[ 1 ] , "-w" ) != 0 && strcmp (argv[ 1 ] , "-a" ) != 0 ) ( pune ("Primul parametru poate fi fie -w, fie -a"< argc- 2 ; i++ ) putc (ch, f[ i] ) ; for (i= 0 ; i < argc- 2 ; i++ ) fclose (f[ i] ) ; return 0 ; }

Explicații pentru cod:

1. Este creată o matrice de cinci pointeri de fișiere. Prin urmare, nu puteți deschide mai mult de cinci fișiere în același timp. Pointerul de fișier al primului fișier va fi stocat în elementul de matrice f, al doilea - în f etc.
2. Numărul de argumente ale liniei de comandă este verificat. Ar trebui să fie cel puțin trei, pentru că... primul este numele programului, al doilea este modul de deschidere a fișierului, al treilea este primul sau singurul fișier în care trebuie scris. Deoarece programul vă permite să deschideți doar cinci fișiere, numărul total de argumente ale liniei de comandă nu poate fi mai mare de șapte. Prin urmare, dacă numărul de argumente este mai mic de 3 sau mai mare de 7, atunci programul se termină, deoarece Declarația return determină ieșirea funcției, chiar dacă există mai mult cod după ea. O valoare returnată de la o funcție care nu este egală cu 0 poate fi interpretată de procesul părinte ca un mesaj că programul sa încheiat cu o eroare.
3. Verifică validitatea celui de-al doilea argument al liniei de comandă. Dacă nu este nici „-w” nici „-a”, atunci expresia condiționată din al doilea if returnează 1 (adevărat). Funcția strcmp() vă permite să comparați șiruri de caractere și returnează 0 dacă sunt egale.
4. Bucla for deschide fișierele la adresele specificate, care încep cu al treilea element al matricei argv. Acesta este motivul pentru care se adaugă 2 la i pentru a obține elementele matricei argv, începând cu a treia. Expresia argc-2 indică numărul de nume de fișiere transmise; deoarece argc stochează numărul total de argumente ale liniei de comandă, dintre care primele două nu sunt nume de fișiere.
5. Expresia argv+1 vă permite să „tăiați” subșirul „w” (sau „a”) din șirul „-w” (sau „-a”), deoarece argv este în esență un pointer către primul element al șirului. Adăugând unul la indicator, îl mutăm la următorul element al matricei.
6. Dacă fișierul nu poate fi deschis, funcția fopen() returnează NULL. În acest caz, programul se încheie.
7. Fiecare caracter introdus de utilizator pe tastatură este scris în toate fișierele deschise.
8. La final dosarele sunt închise.