Principalele argumente ale funcției c. Câteva detalii despre funcția principală. Utilizarea argumentelor din linia de comandă

Vă rugăm să rețineți că această versiune a main() nu are niciun parametru. Cu toate acestea, multe programe necesită o anumită intrare. De exemplu, să presupunem că scrieți un program numit Picture care preia o imagine ca intrare și apoi face o miniatură (o versiune mai mică a imaginii) din imaginea respectivă. Cum știe funcția Imagine ce imagine să accepte și să proceseze? Utilizatorul trebuie să spună programului ce fișier să deschidă. Acest lucru se poate face după cum urmează:

// Program: Poza #include #include int main() ( std::cout<< "Enter name of image-file to create a thumbnail for: "; std::string filename; std::cin >>nume fișier; // Deschideți fișierul imagine // Creați o miniatură // Afișați miniatura)

Cu toate acestea, există o problemă potențială aici. De fiecare dată când programul este lansat, acesta va aștepta intrarea utilizatorului. Aceasta nu este o problemă dacă rulați manual programul din linia de comandă o dată pe imagine. Dar aceasta este deja o problemă dacă doriți să lucrați cu un număr mare de fișiere sau pentru ca un alt program să poată rula acest program.

Să ne uităm la asta mai detaliat.

De exemplu, doriți să creați miniaturi pentru toate fișierele de imagine care se află într-un anumit director. Cum să o facă? Puteți rula acest program de câte ori există imagini în director introducând manual fiecare nume de fișier. Totuși, dacă există sute de imagini, această abordare nu va fi foarte eficientă, ca să spunem ușor! Soluția aici este să scrieți un program care iterează prin fiecare nume de fișier dintr-un director, apelând Picture pe fiecare fișier de fiecare dată.

Acum luați în considerare un caz în care aveți un site web și doriți ca acesta să creeze o miniatură de fiecare dată când un utilizator încarcă o imagine pe site. Acest program nu poate accepta intrare de pe Internet și urmează întrebarea logică: „Atunci, cum să introduceți numele fișierului?” Există o soluție: serverul web apelează automat funcția Imagine de fiecare dată când este descărcat un fișier.

În ambele cazuri, dorim ca programul extern să treacă numele fișierului ca intrare programului nostru atunci când rulează, mai degrabă decât ca Picture în sine să aștepte ca utilizatorul să introducă manual numele fișierului.

Argumente ale liniei de comandă sunt argumente șir opționale transmise de sistemul de operare programului când acesta pornește. Programul le poate folosi ca intrare sau le poate ignora. Așa cum parametrii unei funcții furnizează date pentru parametrii unei alte funcții, argumentele din linia de comandă permit oamenilor sau programelor să ofere intrare unui program.

Trecerea argumentelor liniei de comandă

Programele executabile pot fi lansate pe linia de comandă printr-un apel. De exemplu, pentru a rula fișierul executabil MyProgram, care se află în directorul rădăcină al unității C în sistemul de operare Windows, trebuie să introduceți:

C:\>MyProgram

Pentru a transmite argumente din linia de comandă către MyProgram, va trebui pur și simplu să le enumerați după numele fișierului executabil:

C:\>MyProgram SomeContent.txt

Acum, când rulați MyProgram, SomeContent.txt va fi furnizat ca argument în linia de comandă. Un program poate avea mai multe argumente de linie de comandă, separate prin spații:

C:\>MyProgram SomeContent.txt SomeOtherContent.txt

Acest lucru funcționează și cu alte sisteme de operare, cum ar fi Linux (deși structura directorului va fi diferită de Windows).

Dacă rulați programul dintr-un IDE, atunci IDE-ul dumneavoastră trebuie să ofere o modalitate de a introduce argumentele liniei de comandă.

Pentru utilizatorii Visual Studio: Faceți clic dreapta pe proiectul dorit în Solution Explorer, apoi selectați „Proprietăți”:

Apoi „Proprietăți de configurare > Depanare”. În panoul din dreapta va fi o linie „Argumentele echipei”. Puteți introduce aici argumente în linia de comandă și acestea vor fi transmise automat programului dvs. când acesta pornește:

Cod::Blochează utilizatorii trebuie sa alegi „Proiect > Setați argumentele programului”:

Utilizarea argumentelor din linia de comandă

Acum că știți cum să transmiteți argumente de linie de comandă unui program, următorul pas este să le accesați din cadrul programului. Pentru a face acest lucru, este utilizată o formă diferită a funcției main(), care are două argumente (argc și argv), după cum urmează:

int main(int argc, char *argv)

Puteți vedea și această opțiune:

int main(int argc, char** argv)

Deși ambele aceste opțiuni sunt identice în esență, se recomandă utilizarea primei, deoarece este mai intuitivă.

argc (ing. " arg ument c ount" = "număr de argumente") este un parametru întreg care conține numărul de argumente transmise programului. argc va fi întotdeauna cel puțin 1, deoarece primul argument este întotdeauna numele programului însuși. Fiecare argument de linie de comandă pe care îl oferă utilizatorul va face ca argc să fie incrementat cu 1.

argv (în engleză " arg ument v alues" = "valorile argumentului") este locul unde sunt stocate valorile argumentelor reale. Deși declarația argv pare puțin înfricoșătoare, este doar o matrice. Lungimea acestui tablou este argc.

Să scriem un program scurt numit MyArguments care va imprima valorile tuturor argumentelor din linia de comandă:

// Program: MyArguments #include int main(int argc, char *argv) ( std::cout<< "There are " << argc << " arguments:\n"; // Перебираем каждый аргумент и выводим его порядковый номер и значение for (int count=0; count < argc; ++count) std::cout << count << " " << argv << "\n"; return 0; }

Acum, când apelați MyArguments cu argumentele din linia de comandă SomeContent.txt și 200 , rezultatul va fi după cum urmează:

Sunt 3 argumente:
0 C:\MyArguments
1SomeContent.txt
2 200

Parametrul 0 este calea și numele programului curent. Parametrii 1 și 2 sunt aici argumentele liniei de comandă pe care le-am transmis.

Manipularea argumentelor numerice

Argumentele liniei de comandă sunt întotdeauna transmise ca șiruri de caractere, chiar dacă valoarea furnizată este numerică. Pentru a utiliza un argument de linie de comandă ca număr, va trebui să-l convertiți dintr-un șir într-un număr. Din păcate, C++ face acest lucru puțin mai complicat decât ar trebui să fie:

#include #include #include // pentru std::stringstream #include // pentru exit() int main(int argc, char *argv) ( if (argc<= 1) { // В некоторых операционных системах, argv может быть просто пустой строкой, без имени программы // Обрабатываем случай, когда argv может быть пустым или не пустым if (argv) std::cout << "Usage: " << argv << " " << "\n"; else std::cout << "Usage: " << "\n"; exit(1); } std::stringstream convert(argv); // создаём переменную stringstream с именем convert, инициализируя её значением argv int myint; if (!(convert >> myint)) // efectuează conversia myint = 0; // dacă conversia eșuează, setați myint la valoarea implicită std::cout<< "Got integer: " << myint << "\n"; return 0; }

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 numele programului

numele programului 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) ; returnează 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 delimitătoare.

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 dvs. de operare setează 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 din linia 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() cum 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ă parametri 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.

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 șiruri. 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 INTRODUCE 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.

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

int main(int argc, char * argv)
{…}

Antetul funcției conține semnătura funcției principale main() cu argumentele argс și argv.
Dacă rulați un program prin linia de comandă, atunci este posibil să transferați unele informații în acest program. Există argumente în linia de comandă argc și argv pentru aceasta.
Parametrul argc este de tip int și conține numărul de parametri trecuți funcției principale. Mai mult, argc este întotdeauna cel puțin 1, chiar și atunci când nicio informație nu este transmisă funcției principale, deoarece primul parametru este numele aplicației.
Parametrul argv este o matrice de pointeri către șiruri. Prin linia de comandă pot fi transmise doar datele șiruri.

Când rulați un program prin linia de comandă Windows, îi puteți transmite câteva informații. În acest caz, linia de comandă va arăta astfel:
Drive:\cale\nume.exe argument1 argument2 ...

Argumentele liniei de comandă sunt separate prin unul sau mai multe spații.

Argumentul argv conține numele complet al aplicației:

#include
folosind namespace std;

cout<< argv << endl;

Întoarce 0;
}

Rezultatul executiei

Exemplu: Calcularea produsului a două numere întregi
Programul folosește funcția pentru a converti un șir într-un număr întreg StrToInt() de aici.

#include
folosind namespace std;
int StrToInt(char *s) (...)
int main(int argc, char * argv) (

Int a = 0, b=0;

Dacă (argc > 1)

a = StrToInt(argv);

Dacă (argc > 2)

b = StrToInt(argv);

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

Întoarce 0;
}

Programul se lansează după cum urmează:

Rezultatul executiei

Depanarea unui program cu argumente de linie de comandă

Pentru a transmite argumente în linia de comandă atunci când depanați un program, trebuie să accesați meniul Proprietăți proiect.


Pe fila Proprietăți de configurare ->Depanare alege Argumente de comandăși stabiliți-le valorile.

Când rulați programul în modul de depanare, argumentele introduse vor fi tratate de program ca argumente în linia de comandă.

Argumente opționale și numite

Argumente opționale

C# 4.0 introduce o nouă caracteristică care face mai ușoară specificarea argumentelor la apelarea unei metode. Acest remediu se numește argumente opționaleși vă permite să definiți o valoare implicită pentru un parametru de metodă. Această valoare va fi utilizată implicit dacă nu este specificat un argument corespunzător pentru parametru la apelarea metodei. Prin urmare, nu este necesar să se furnizeze un argument pentru un astfel de parametru. Argumentele opționale facilitează apelarea unor metode în care argumentele implicite sunt aplicate unor parametri. Ele pot fi, de asemenea, folosite ca formă de „scurtătură” a supraîncărcării metodei.

Principalul impuls pentru adăugarea argumentelor opționale a fost nevoia de a simplifica interacțiunea cu obiectele COM. Mai multe modele de obiecte Microsoft (cum ar fi Microsoft Office) oferă funcționalitate prin obiecte COM, dintre care multe au fost scrise cu mult timp în urmă și sunt concepute pentru a prelua parametri opționali.

Un exemplu de utilizare a argumentelor opționale este prezentat mai jos:

Utilizarea sistemului; folosind System.Collections.Generic; folosind System.Linq; folosind System.Text; namespace ConsoleApplication1 ( clasa Program ( // Argumentele b și c sunt opționale când se apelează static int mySum(int a, int b = 5, int c = 10) ( return a + b + c; ) static void Main() ( int sum1 = mySum(3); int sum2 = mySum(3,12); Console.WriteLine("Sum1 = "+sum1); Console.WriteLine("Sum2 = "+sum2); Console.ReadLine(); ) ) )

Trebuie reținut că toate argumentele opționale trebuie specificate în dreapta celor solicitate. Pe lângă metode, argumentele opționale pot fi folosite în constructori, indexatori și delegați.

Un beneficiu al argumentelor opționale este că ele fac mai ușor pentru programator gestionarea apelurilor complexe de metode și constructori. La urma urmei, este adesea necesar să specificați mai mulți parametri într-o metodă decât este necesar de obicei. Și în astfel de cazuri, unii dintre acești parametri pot fi opționali prin utilizarea atentă a argumentelor opționale. Aceasta înseamnă că trebuie să transmiteți doar acele argumente care sunt importante într-un caz dat și nu toate argumentele care altfel ar fi necesare. Această abordare vă permite să raționalizați metoda și să simplificați manipularea ei de către programator.

Argumente numite

O altă caracteristică care a fost adăugată la C# odată cu lansarea .NET 4.0 este suportul pentru așa-numitul argumente numite. După cum știți, atunci când treceți argumente unei metode, ordinea acestora, de regulă, trebuie să coincidă cu ordinea în care parametrii sunt definiți în metoda însăși. Cu alte cuvinte, valoarea argumentului este atribuită parametrului pe baza poziției acestuia în lista de argumente.

Argumentele numite sunt concepute pentru a depăși această limitare. Un argument numit vă permite să specificați numele parametrului căruia îi este atribuită valoarea. Și în acest caz, ordinea argumentelor nu mai contează. Astfel, argumentele numite sunt oarecum similare cu inițializatoarele de obiecte menționate anterior, deși diferă de ele prin sintaxa lor. Pentru a specifica un argument după nume, utilizați următoarea formă de sintaxă:

nume_parametru: valoare

Aici nume_parametru denotă numele parametrului căruia i se transmite valoarea. Desigur, parameter_name trebuie să fie numele parametrului real pentru metoda apelată.