Čo znamená int main v c. Rozdiel medzi int main() a int main(void)? Formálne a skutočné parametre

Hlavná funkcia.

Každý program v C a C++ musí mať hlavnú funkciu; a je len na vás, kam ho umiestnite. Niektorí programátori ho umiestňujú na začiatok súboru, niektorí na koniec. Bez ohľadu na jeho polohu si však musíte zapamätať nasledovné: Argumenty k „hlavnej“ funkcii. Spúšťacia procedúra Borland C++ posiela hlavnej funkcii tri parametre (argumenty): argc, argv a env. - argc, celé číslo, je počet argumentov príkazového riadka odoslaných hlavnej funkcii, - argv je pole ukazovateľov na reťazce (char *). Pod DOSom 3.xa novším je argv definovaná ako úplná cesta programu, ktorý sa má spustiť. Pri spustení v starších verziách DOSu argv ukazuje na nulový reťazec (""). argv ukazuje na prvý riadok príkazového riadku za názvom programu. argv ukazuje na druhý riadok príkazového riadku za názvom programu. argv ukazuje na posledný argument odoslaný do main. argv obsahuje NULL. - env je tiež pole ukazovateľov na reťazce. Každý prvok env obsahuje reťazec v tvare ENVVAR=hodnota. ENVVAR je názov premennej prostredia, ako je PATH alebo 87.<значение>toto je hodnota danej premennej prostredia, napríklad C:\DOS;C:\TOOLS (pre PATH) alebo YES (pre 87). Upozorňujeme však, že ak zadáte niektoré z týchto argumentov, musíte ich zadať v tomto poradí: argc, argv, env. Platné sú napríklad nasledujúce deklarácie argumentov: main() main(int argc) /* platné, ale nie veľmi dobré */ main(int argc, char *argv) main(int argc, char *argv, char *env) Main (int) deklarácia argc) nie je príliš pohodlná, pretože pri znalosti množstva parametrov k nim sami nemáte prístup. Argument env je vždy prístupný prostredníctvom globálnej premennej prostredia. Pozrite si premennú prostredia (v kapitole 3) a funkcie putenv a getenv (v kapitole 2). Parametre argc a argv sú dostupné aj prostredníctvom premenných _argc a _argv. Príklad programu používajúci argc, argv a env. Toto je príklad programu ARGS.EXE, ktorý demonštruje najjednoduchší spôsob použitia argumentov odovzdaných hlavnej funkcii. /* Program ARGS.C */ #include #include void main(int argc, char *argv, char *env) ( int i; printf("Hodnota argc je %d \n\n",argc); printf("Príkazový riadok obsahuje %d parametrov \n\ n" argc); pre (i=0; i<=argc; i++) printf(" argv[%d]: %s\n",i,argv[i]); printf("Среда содержит следующие строки:\n"); for (i=0; env[i] != NULL; i++) printf(" env[%d]: %s\n",i,env[i]); return 0; } Предположим, что вы запускаете программу ARGS.EXE со следующей командной строкой: C:> args first_arg "arg s medzerami" 3 4 "posledný, pred jedným" zastavte sa! Všimnite si, že argument môžete poslať s medzerami tak, že ho uzatvoríte do dvojitých úvodzoviek, ako je to znázornené v príkladoch „argument s medzerami“ a „predposledný“ vo volaní programu. Ako výsledok spustenia programu dostanete niečo ako nasledovné: Hodnota argc je 7 Príkazový riadok obsahuje 7 parametrov argv: c:\turboc\testargs.exe argv: first_arg argv: arg s prázdnym argv: 3 argv : 4 argv: predposledný argv: stop! Prostredie obsahuje nasledujúce riadky: env: COMSPEC=C:\COMMAND.COM env: PROMPT=$p $g env: PATH=C:\SPRINT;C:\DOS;C:\BC Maximálna celková dĺžka príkazového riadku odoslaná do hlavnej funkcie (vrátane medzier a samotného názvu programu), nesmie presiahnuť 128 znakov; Toto sú obmedzenia systému DOS. Únikové znaky príkazového riadku Argumenty príkazového riadka môžu obsahovať znaky escape. Môžu sa však rozšíriť pre všetky názvy súborov, ktoré sa zhodujú s argumentom, rovnakým spôsobom, ako sa to robí napríklad pomocou príkazu copy DOS. Ak chcete použiť symboly escape, pri prepájaní vášho programu s linkerom musíte zahrnúť objektový súbor WILDARGS.OBJ, ktorý sa dodáva s Borland C++. Ak je súbor WILDARGS.OBJ pripojený k vášmu programu, môžete použiť argumenty ako "*.*" na príkazovom riadku. V tomto prípade sa názvy všetkých súborov zodpovedajúcich tejto maske zadajú do poľa argv. Maximálna veľkosť poľa argv závisí len od veľkosti oblasti dynamickej pamäte. Ak sa pre danú masku nenašli žiadne vhodné súbory, argument sa odovzdá vo forme, v akej bol napísaný na príkazovom riadku. (To znamená, že hlavnej funkcii sa odovzdá reťazec obsahujúci znaky escape). Argumenty v úvodzovkách ("...") nie sú rozšírené. Príklad. Nasledujúce príkazy skompilujú súbor ARGS.C a prepoja ho s modulom WILDARGS.OBJ a potom spustite výsledný program ARGS.EXE: bcc args wildarg.obj args C:\BORLANDC\INCLUDE\*.H "*.C" Pri spustení ARGS.EXE sa prvý argument rozšíri na názvy všetkých súborov s príponou H v adresári Borland C++ INCLUDE. Upozorňujeme, že všetky riadky obsahujú úplnú trasu (napríklad C:\TC\INCLUDE\ALLOC.H). Argument *.C nie je rozšírený, pretože je to uvedené v úvodzovkách. Ak pracujete v integrovanom prostredí (BC.EXE), potom jednoducho musíte zadať v ponuke projektu názov súboru projektu, ktorý by mal obsahovať nasledujúce riadky: ARGS WILDARGS.OBJ Potom pomocou príkazu „Spustiť/Argumenty ", mali by ste nastaviť parametre príkazového riadku. Komentujte. Ak chcete, aby spracovanie escape znakov prebiehalo vždy, t.j. Aby sa WILDARGS.OBJ automaticky prepojil editorom odkazov, musíte upraviť svoju štandardnú knižnicu C?.LIB tak, aby obsahovala súbor WILDARGS.OBJ. Ak to chcete urobiť, odstráňte SETARGV z knižnice a pridajte WILDARGS. Dá sa to urobiť pomocou nasledujúcich príkazov (predpokladáme, že štandardné knižnice a WILDARGS.OBJ sa nachádzajú v aktuálnom adresári): TLIB je popísaný v kapitole 7, Pomôcky, Príručky používateľa. tlib cs -setargv +wildargs tlib cc - setargv +wildargs tlib cm -setargv +wildargs tlib cl -setargv +wildargs tlib ch -setargv +wildargs Kompilácia pomocou prepínača -p (konvencia volania Pascal) Ak kompilujete svoj program pomocou konvencie volania Pascal (podrobne popísané v kapitole 9 " Pri prepojení s jazykom symbolických inštrukcií, "Príručka programátora") si musíte uvedomiť, že hlavná funkcia musí byť explicitne deklarovaná ako funkcia C. To sa dá urobiť pomocou kľúčové slovo cdecl je niečo ako toto: cdecl main(int argc, char *argv, char *env) Hodnota vrátená funkciou main. Hlavná funkcia vracia hodnotu, ktorá je ukončovacím kódom programu: toto je celé číslo. Ak však váš program používa na ukončenie funkciu exit (alebo _exit), potom vrátená hodnota bude argumentom tejto funkcie. Ak napríklad váš program obsahuje volanie: exit(1), ukončovací kód bude 1. Ak na spustenie programu používate integrované prostredie Borland C++ (BC.EXE), môžete zobraziť návratovú hodnotu hlavného vyberte "Súbor | Získať informácie".

Strana 53 z 85

1.5.3. Odovzdávanie parametrov hlavnej funkcii

Hlavná funkcia, ktorá začína vykonávanie programu v jazyku C, môže byť definovaná parametrami, ktoré sa odovzdávajú z externého prostredia, napríklad z príkazového riadku. Externé prostredie má svoje pravidlá pre reprezentáciu dát, respektíve všetky dáta sú prezentované vo forme znakových reťazcov. Na odovzdanie týchto reťazcov hlavnej funkcii sa používajú dva parametre, prvý parameter sa používa na prenos počtu reťazcov, ktoré sa majú preniesť, druhý sa používa na prenos samotných reťazcov. Bežné (ale nie povinné) názvy týchto parametrov sú argc a argv. Parameter argc je typu int, jeho hodnota je vytvorená analýzou príkazového riadku a rovná sa počtu slov na príkazovom riadku vrátane názvu volaného programu (slovo je akýkoľvek text, ktorý neobsahuje medzeru charakter). Parameter argv je pole ukazovateľov na reťazce, z ktorých každý obsahuje jedno slovo z príkazového riadku. Ak slovo musí obsahovať znak medzery, musí byť pri písaní do príkazového riadku uvedené v úvodzovkách.

Hlavná funkcia môže mať aj tretí parameter, ktorý sa zvyčajne nazýva argp a ktorý slúži na prenos parametrov operačného systému (prostredia), v ktorom sa program v programovacom jazyku C vykonáva, do hlavnej funkcie.

Hlavička hlavnej funkcie vyzerá takto:

Ak napríklad príkazový riadok programu v programovacom jazyku C vyzerá takto:

A:\>cprog fungujúci "program C" 1

potom sú argumenty argc, argv, argp reprezentované v pamäti, ako je znázornené na diagrame na obr.

Argc[4]
argv --> -->
-->
-->
-->
argp --> -->
-->
-->
-->
Obr.1. Rozloženie možností príkazového riadku

Operačný systém podporuje odovzdávanie hodnôt pre parametre argc, argv, argp a je zodpovednosťou užívateľa odovzdať a použiť aktuálne argumenty do hlavnej funkcie.

Nasledujúci príklad je program, ktorý vypíše skutočné argumenty odovzdané hlavnej funkcii z operačného systému a parametrov operačného systému.

Príklad:
int main (int argc, char *argv, char *argp)
(int i=0;
printf("\nNázov programu %s", argv);
pre (i=1; i>=argc; i++)
printf("\n argument %d je %s", argv[i]);
printf("\nNastavenia operačného systému:");
zatiaľ čo (*argp)
( printf ("\n %s",*argp);
argp++;
}
return(0);
}

K parametrom operačného systému je možné pristupovať aj pomocou funkcie knižnice geteuv, jej prototyp vyzerá takto:

char *geteuv (const char *varname);

Argument tejto funkcie určuje názov parametra prostredia, ktorého ukazovateľ na hodnotu vráti funkcia geteuv. Ak zadaný parameter nie je momentálne definovaný v prostredí, návratová hodnota je NULL.

Pomocou ukazovateľa získaného funkciou geteuv môžete hodnotu parametra operačného systému iba prečítať, ale nemôžete ju zmeniť. Funkcia puteuv sa používa na zmenu hodnoty systémového parametra.

Kompilátor programovacieho jazyka C zostaví program v jazyku C tak, že na začiatku programu sa vykoná určitá inicializácia, ktorá okrem iného zahŕňa spracovanie argumentov odovzdaných hlavnej funkcii a odovzdanie hodnôt parametrov prostredia. Tieto akcie vykonávajú funkcie knižnice _setargv a _seteuv, ktoré sú kompilátorom vždy umiestnené pred hlavnou funkciou.

Ak program v programovacom jazyku C nepoužíva odovzdávanie argumentov a hodnôt parametrov operačného systému, potom je vhodné zakázať používanie knižničných funkcií _setargv a _seteuv umiestnením do programu C v programovacom jazyku, pred hlavnou funkciou, funkcie s rovnakými názvami, ktoré však nevykonávajú žiadne akcie (stub). Začiatok programu v tomto prípade bude vyzerať takto:

setargv()
}
-seteuv()
( return ; /* prázdna funkcia */
}
int main()
( /* hlavná funkcia bez argumentov */
...
...
renurn(0);
}

Vo vyššie uvedenom programe sa pri volaní knižničných funkcií _setargv a _seteuv použijú funkcie vložené do programu používateľom a nebudú vykonávať žiadne akcie. Tým sa výrazne zníži veľkosť výsledného exe súboru.

Borland C++ podporuje tri argumenty pre main(). Prvé dva sú tradičné argc a argv. Toto sú jediné argumenty pre main() definované štandardom ANSI C. Umožňujú odovzdanie argumentov príkazového riadka programu. Argumenty príkazového riadka sú informácie, ktoré nasledujú za názvom programu na príkazovom riadku operačného systému. Napríklad, keď je program kompilovaný pomocou riadkového kompilátora Borland, zvyčajne sa zadáva bcc názov_programu

Kde názov_programu je program, ktorý je potrebné skompilovať. Názov programu sa odovzdá kompilátoru ako argument.

Parameter argc obsahuje počet argumentov príkazového riadku a je to celé číslo. Vždy sa rovná aspoň 1, pretože názov programu sa kvalifikuje ako prvý argument. Parameter argv je ukazovateľ na pole ukazovateľov znakov. Každý prvok tohto poľa ukazuje na argument príkazového riadka. Všetky argumenty príkazového riadku sú reťazce. Všetky čísla prevedie program do interného formátu. Nasledujúci program vypíše „Ahoj“, za ktorým nasleduje používateľské meno, keď je napísané priamo za názvom programu:

#include

{
if(argc!=2)
{
printf("Zabudli ste zadať svoje meno\n");
návrat 1;
}
printf("Ahoj %s", argv);
návrat 0;
}

Ak zavoláte tento názov programu a používateľské meno je Sergey, na spustenie programu by ste mali zadať:
meno Sergey.
V dôsledku programu sa zobrazí nasledovné:
"Ahoj Sergey."

Argumenty príkazového riadka musia byť oddelené medzerami alebo tabulátormi. Čiarky, bodkočiarky a podobné znaky sa nepovažujú za oddeľovače. Napríklad:

Pozostáva z troch riadkov, pričom

Herb, Rick, Fred

Toto je jeden riadok – čiarky nie sú oddeľovače.

Ak potrebujete zadať reťazec obsahujúci medzery alebo tabulátory ako jeden argument, musíte ho uzavrieť do dvojitých úvodzoviek. Napríklad toto je jeden argument:

"toto je test"

Je dôležité správne deklarovať argv. Najtypickejšia metóda je:

Prázdne zátvorky označujú, že pole nemá pevnú dĺžku. Môžete pristupovať jednotlivé prvky pomocou indexovania argv. Napríklad argv ukazuje na prvý riadok, ktorý vždy obsahuje názov programu. argv ukazuje na ďalší riadok a tak ďalej.

Nižšie je uvedený malý príklad použitia argumentov príkazového riadku. Odpočítava od hodnoty zadanej na príkazovom riadku a vyšle signál, keď dosiahne nulu. Všimnite si, že prvý argument obsahuje číslo prevedené na celé číslo pomocou štandardnej funkcie atoi(). Ak je reťazec "zobrazenie" prítomný ako druhý argument, potom sa na obrazovke zobrazí samotné počítadlo.

/* program na počítanie */

#include
#include
#include
int main(int argc, char *argv)
{
int disp, počet;
if(argc<2)
{
printf("Musíte zadať dĺžku počítania\n");
printf("na príkazovom riadku. Skúste to znova.\n");
návrat 1;
}
if (argc==3 && !strcmp(argv,"zobrazit")) disp = 1;
inak disp = 0;
for(count=atoi(argv); count; -count)
if (disp) printf("%d ", pocet);
printf("%c", "\a"); /* na väčšine počítačov ide o volanie */
návrat 0;
}

Upozorňujeme, že ak nie sú zadané žiadne argumenty, zobrazí sa chybové hlásenie. Toto je najtypickejšie pre programy, ktoré používajú argumenty príkazového riadka na zadávanie pokynov, ak bol vykonaný pokus o spustenie programu bez správnych informácií.

Ak chcete získať prístup k jednotlivým znakom príkazového riadka, pridajte do argv druhý index. Napríklad nasledujúci program vypíše všetky argumenty, pomocou ktorých bol volaný, po jednom znaku:

#include
int main(int argc, char *argv)
{
int t, i;
for(t=0; t {
i = 0;
while(argv[t][i])
{
printf("%c", argv[t][i]);
}
printf(" ");
}
návrat 0;
}

Musíme si uvedomiť, že prvý index slúži na prístup k reťazcu a druhý je na prístup k znaku v reťazci.

Typicky sa argc a argv používajú na získanie zdrojových príkazov. Teoreticky je možné mať až 32 767 argumentov, no väčšina operačných systémov vám ani nedovolí sa k tomu priblížiť. Tieto argumenty sa zvyčajne používajú na určenie názvu súboru alebo možností. Použitie argumentov príkazového riadku dáva programu profesionálny vzhľad a umožňuje použitie programu v dávkových súboroch.

Ak zahrniete súbor WILDARGS.OBJ dodávaný s Borland C++, môžete použiť šablóny v argumentoch typu *.EXE. (Borland C++ automaticky spracováva zástupné znaky a zodpovedajúcim spôsobom zvyšuje argc.) Ak napríklad pripojíte WILDARGS.OBJ k nasledujúcemu programu, povie vám, koľko súborov zodpovedá názvu súboru zadanému v príkazovom riadku:

/* Prepojte tento program s WILDARGS.OBJ */

#include
int main(int argc, char *argv)
{
register int i;
printf("%d súborov zodpovedá zadanému názvu\n", argc-1);
printf("Sú to: ");
pre (i=1; i printf("%s", argv[i]);
návrat 0;
}

Ak tento program nazveme WA, potom ho spustíme nasledovne, dostaneme počet súborov s príponou EXE a zoznam názvov týchto súborov:

Okrem argc a argv poskytuje Borland C++ aj tretí argument príkazového riadka -env. Parameter env umožňuje programu prístup k informáciám o prostredí operačného systému. Parameter env musí nasledovať po argc a argv a je deklarovaný takto:

Ako vidíte, env sa deklaruje rovnakým spôsobom ako argv. Rovnako ako argv, je to ukazovateľ na pole reťazcov. Každý riadok je reťazec prostredia definovaný operačným systémom. Parameter env nemá žiadny ekvivalentný parameter argc, ktorý hovorí, koľko riadkov prostredia existuje. Namiesto toho je posledný riadok prostredia nulový. Nasledujúci program vytlačí všetky reťazce prostredia aktuálne definované v operačnom systéme:

/* tento program zobrazí všetky riadky prostredia */

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

Upozorňujeme, že hoci argc a argv program nepoužíva, musia sa nachádzať v zozname parametrov. C nepozná názvy parametrov. Namiesto toho je ich použitie určené poradím, v ktorom sú parametre deklarované. V skutočnosti môžete parameter nazvať akokoľvek chcete. Keďže argc, argv a env sú tradičné názvy, je najlepšie ich naďalej používať, aby každý, kto číta program, okamžite pochopil, že ide o argumenty funkcie main().

Typickou úlohou programov je vyhľadať hodnotu definovanú v reťazci prostredia. Napríklad obsah riadku PATH umožňuje programom používať vyhľadávacie cesty. Nasledujúci program ukazuje, ako nájsť reťazce, ktoré deklarujú štandardné vyhľadávacie cesty. Používa štandardnú knižničnú funkciu strstr(), ktorá má nasledujúci prototyp:

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

Funkcia strstr() hľadá reťazec, na ktorý ukazuje str1, v reťazci, na ktorý ukazuje str2. Ak sa takýto reťazec nájde, vráti sa ukazovateľ na prvú pozíciu. Ak sa nenájdu žiadne zhody, funkcia vráti hodnotu NULL.

/* program hľadá medzi reťazcami prostredia riadok obsahujúci PATH */

#include
#include
int main (int argc, char *argv, char *env)
{
int t;
for(t=0; env[t]; t++)
{
if(strstr(env[t], "PATH"))
printf("%s\n", env[t]);
}
návrat 0;
}

Akýkoľvek program v jazyku C začína volaním funkcie main(). Táto funkcia by mala byť v každom programe.

Ako každá iná funkcia, aj funkcia main() môže mať parametre. Niekedy je užitočné pri spustení programu odovzdať mu nejaké informácie. Tieto informácie sa odovzdávajú do main() pomocou argumentov príkazového riadka. Argumenty príkazového riadku– sú to informácie, ktoré sa zadávajú do príkazového riadka za názvom programu, keď sa program spúšťa na spustenie mimo vývojového prostredia programu. Ak chcete napríklad začať archivovať súbor task.cpp, musíte do príkazového riadka zadať nasledovné:

winrar archTasktask.cpp // winrar.exe archTasktask.cpp

kde winrar je názov programu archivácie a riadky „ a», « archTask"A" úloha. cpp» predstavuje argumenty príkazového riadka, ktoré hovoria programu, aby vytvoril archív (" a") S menom archTask z jedného súboru úloha. cpp.

Pri odovzdávaní parametrov do funkcie main() musí byť táto funkcia definovaná takto:

int main(int argc, char *argv) ( ) // alebo void main(...)()

Parameter argc obsahuje počet argumentov na príkazovom riadku a je to celé číslo a vždy je to aspoň 1, pretože prvý argument je vždy názov programu (názov programu s úplnou cestou k programu).

Parameter argv je ukazovateľ na pole ukazovateľov na reťazce. V tomto poli každý prvok ukazuje na ďalší argument príkazového riadka. Prázdne hranaté zátvorky označujú, že pole má neurčitú dĺžku. K jednotlivým argumentom sa dostanete indexovaním poľa argv. Napríklad argv ukazuje na prvý znakový reťazec, ktorý je vždy názvom programu; argv poukazuje na prvý argument a tak ďalej. Zoznam argumentov je obmedzený na NULL, t.j. argv == NULL.

Ak chcete získať prístup k jednotlivému znaku jedného z argumentov príkazového riadka, musíte použiť druhý index v argv. To znamená, že prvý index argv poskytuje prístup k reťazcu a druhý index poskytuje prístup k jeho jednotlivým znakom.

Všetky argumenty príkazového riadku sú reťazce, takže prevod číselných parametrov do požadovaného formátu musí byť zabezpečený v programe pri jeho vývoji.

Príklad programu s rôznymi spôsobmi prevodu čísel v symbolickom formáte na celé a reálne čísla:

#include

// pri štarte nastavíme napríklad tieto argumenty: 100 2.7

void main(int a, char *b) (

k = strtol(b, &ptr, 10); // ptr = adresa chyby v riadku

f = strtod(b, &ptr);

sscanf(b, "%d", &k);

sscanf(b, "%lf", &f);

Názvy argc a argv sú tradičné, ale nevyžadujú sa. Tieto dva parametre vo funkcii main() môžete nazvať akokoľvek chcete.

Jednoduchý príklad použitia argumentov príkazového riadku:

int main(int argc, char *argv) (

if (argc != 4) (

printf("Neplatné parametre spustenia programu!\n");

k = atoi(argv); // konverzia parametra číslo

printf("Dobrý deň, %s zo skupiny %s z %d roka",

Ak je názov programu úloha a vaše meno je „Vasya“, skupina „PM-11“ od prvého ročníka, potom na spustenie programu zadajte do príkazového riadku:

úloha Vasja PM-11 1

V dôsledku vykonania programu sa na obrazovke objaví nasledujúca správa: „Ahoj, Vasya zo skupiny 1. ročník PM-11.“

Upozorňujeme, že ak nie sú zadané všetky argumenty príkazového riadka, zobrazí sa chybové hlásenie. Programy, ktoré používajú argumenty príkazového riadka, často robia nasledovné: Keď používateľ spustí tieto programy bez zadania požadovaných informácií, zobrazia sa pokyny, ako správne zadať argumenty.

Argumenty príkazového riadku musia byť oddelené medzerou. Ak sú v samotnom argumente medzery, potom, aby sa mu zabránilo vo vytváraní viacerých argumentov, musí byť tento argument uzavretý do dvojitých úvodzoviek. V dôsledku toho sa celý reťazec v úvodzovkách bude považovať za jeden argument. Program je možné spustiť napríklad takto: úloha „Vasya a Petya“ PM-21 2. V dôsledku vykonania programu sa na obrazovke zobrazí správa: „Ahoj, Vasya a Petya z 2. ročníka PM- Skupina 21."

Čo je char *argv? Toto pole, ktorého prvkami sú ukazovatele, teda pole ukazovateľov. To znamená, že pri odovzdávaní parametrov do main() môže byť definovaný takto:

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

Úloha. Zobraziť všetky argumenty príkazového riadku (nie je potrebné zobrazovať názov programu).

#include

void main(int argc, char *argv)(

pre (i = 1; i< argc; i++)

printf("%s\n", argv[i]);

Druhá možnosť =================

#include

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

while((p=*argv) != NULL) (

printf("%s\n", p);

Argumenty príkazového riadka sa zvyčajne používajú na poskytnutie počiatočných údajov programu, ktoré bude potrebovať pri spustení (napríklad argumenty príkazového riadka často odovzdávajú údaje, ako je názov súboru alebo parametre spustenia programu).

Keď program nevyžaduje parametre príkazového riadka, funkcia main() použije kľúčové slovo void vo svojom zozname parametrov (alebo jednoducho nič nešpecifikuje).

Ako ladiť v B.C. programy, ktoré vyžadujú argumenty príkazového riadku. V menu Spustiť→Argumenty... musíte zadať argumenty príkazového riadku. Nie je potrebné zadávať názov programu. Potom môžete jednoducho spustiť a ladiť program vo vývojovom prostredí ako zvyčajne.

Pozastavte AdBlock na tejto stránke.

Prečo teda potrebujeme vlastné funkcie? Používateľom definované funkcie sú potrebné na to, aby programátorom uľahčili písanie programov.

Pamätajte, že sme hovorili o programovacích paradigmách, presnejšie o štruktúrovanom programovaní. Hlavnou myšlienkou bolo, že každý program možno napísať iba pomocou troch základných konštruktov: nasledovať, podmienka a slučka. Teraz k týmto štruktúram pridáme ešte jednu – „podprogramy“ – a získame novú paradigmu procedurálne programovanie".

Jediný rozdiel je v tom, že jednotlivé časti nášho hlavného programu (najmä opakujúce sa) napíšeme vo forme samostatných funkcií (podprogramy, procedúry) a budeme ich volať podľa potreby. Program teraz v podstate popíše interakciu rôznych funkcií.

Takže v tomto návode budeme podrobne diskutovať o tom, ako sa funkcie vytvárajú interne. Dozvieme sa tiež, ako vytvoriť vlastné funkcie.

Ako fungujú funkcie

Pripomeňme si informácie z prvej lekcie. Všetky funkcie, vrátane tých, ktoré napísal používateľ, sú usporiadané podobným spôsobom. Majú dve hlavné časti: hlavičku funkcie a telo funkcie.

Výpis 1.

Int main(void)( // hlavička funkcie // telo funkcie je napísané v zložených zátvorkách)

S telom funkcie je všetko jasné: popisuje algoritmus funkcie. Pozrime sa na názov. Pozostáva z troch povinných častí:

návratový typ;
názov funkcie;
argumenty funkcie.

Najprv sa zapíše návratový typ, napríklad int , ako vo funkcii main. Ak funkcia nemá vrátiť programu žiadnu hodnotu, potom sa na toto miesto zapíše kľúčové slovo void. Zdalo by sa, že keďže funkcia nič nevracia, nie je potrebné nič písať. Predtým sa to mimochodom robilo v jazyku C, ale potom to pridali kvôli jednotnosti. V súčasnosti moderné kompilátory vydávajú varovania/chyby, ak nešpecifikujete návratový typ.
V niektorých programovacích jazykoch sa funkcie, ktoré nevracajú žiadnu hodnotu, nazývajú procedúry (napríklad Pascal). Okrem toho existujú rôzne syntaxe na vytváranie funkcií a procedúr. V jazyku C takáto diskriminácia neexistuje.

Názov funkcie sa zapíše za návratový typ. No, za názvom sú uvedené typy a počet argumentov, ktoré sú odovzdané funkcii.

Pozrime sa na nadpisy funkcií, ktoré už poznáme.

Výpis 2.

// funkcia s názvom srand, ktorá berie celé číslo, nevracia nič void srand(int) // funkcia s názvom sqrt, ktorá berie skutočný float, vracia float float sqrt(float) // funkcia s názvom rand, ktorá neberie žiadne argumenty, vracia celé číslo int rand(void) //funkcia s názvom pow, ktorá berie dva argumenty typu double, vracia skutočné číslo typu double double pow(double, double)

Ako vytvoriť vlastnú funkciu

Ak chcete vytvoriť svoju vlastnú funkciu, musíte ju úplne opísať. Tu platí všeobecné pravidlo: pred použitím deklarujte a popíšte, ako by mal fungovať. Aby sme to urobili, vráťme sa k diagramu štruktúry programu v jazyku C, ktorý sme mali hneď na prvej lekcii. Označme na ňom miesta, kde možno popísať funkcie.

Obr.1 Objasnenie štruktúry programu. Vyhlásenie o funkciách.

Ako vidíte, existujú dve miesta, kde sa to dá urobiť.

Pozrime sa na príklad, ktorý ilustruje vytvorenie vlastnej funkcie na výpočet maxima dvoch čísel.

Výpis 3.

#include // deklaruje vlastnú funkciu s názvom max_num // vstup: dva celočíselné parametre pomenované a a b // výstup: maximum z dvoch argumentov int max_num(int a, int b)( int max = b; if (a > b) max = a; návrat max; ) //hlavný program int main(void) ( int x = 0, y = 0; int m = 0; scanf("%d %d", &x, &y); m = max_num( x ,y); printf("max(%d,%d) = %d\n",x,y,m); return 0; )

Dovoľte mi podrobne popísať, ako bude tento program fungovať. Spustí sa telo hlavnej funkcie. Vzniknú celočíselné premenné x, y a m. Premenné x a y sa čítajú z klávesnice. Povedzme, že sme zadali 3 5, potom x = 3, y = 5. Toto všetko by vám malo byť jasné. Teraz ďalší riadok

Výpis 4.

M = max_num(x,y);

Premenná m musí byť priradená tomu, čo je napravo od znamienka =. Tam máme názov funkcie, ktorú sme sami vytvorili. Počítač hľadá deklaráciu a popis tejto funkcie. Nachádza sa vyššie. Podľa tejto deklarácie musí táto funkcia akceptovať dve celočíselné hodnoty. V našom prípade sú to hodnoty zapísané v premenných x a y. Tie. čísla 3 a 5. Upozorňujeme, že do funkcie sa neodovzdávajú samotné premenné x a y, ale iba hodnoty (dve čísla), ktoré sú v nich uložené. To, čo je v skutočnosti odovzdané funkcii, keď je volaná v programe, sa nazýva skutočné parametre funkcie.

Teraz sa spustí funkcia max_num. Prvým krokom je vytvorenie samostatnej dočasnej premennej pre každý parameter opísaný v hlavičke funkcie. V našom prípade sa vytvoria dve celočíselné premenné s názvom a a b. Týmto premenným sú priradené hodnoty skutočných parametrov. Samotné parametre, popísané v hlavičke funkcie, sa nazývajú formálne parametre. Formálnym parametrom a a b sú teda priradené hodnoty skutočných parametrov 3 a 5. Teraz a = 3, b = 5. Ďalej vo funkcii môžeme s týmito premennými pracovať, ako keby to boli obyčajné premenné.

Vytvorí sa celočíselná premenná s názvom max a priradí sa jej hodnota b. Ďalej sa kontroluje podmienka a > b. Ak je to pravda, potom by sa mala hodnota v premennej max nahradiť znakom .

Nasleduje príkaz return, ktorý vráti volajúcemu programu (hlavnej funkcii) hodnotu zapísanú v premennej max, t.j. 5. Potom sa premenné a, b a max odstránia z pamäte. A vraciame sa na rad

Výpis 5.

M = max_num(x,y);

Funkcia max_num vrátila hodnotu 5, čo znamená, že teraz je napravo od znamienka = zapísaná 5. Táto hodnota sa zapíše do premennej m. Potom sa riadok zobrazí na obrazovke a program sa ukončí.

Ešte raz si pozorne prečítajte posledné 4 odseky, aby ste plne pochopili, ako program funguje.

Medzitým vám poviem, prečo je potrebný spodný blok popisov funkcií. Predstavte si, že ste vo svojom programe napísali 20 malých funkcií. A všetky sú opísané pred hlavnou funkciou. Dostať sa tak dlho do hlavného programu nie je veľmi pohodlné. Na vyriešenie tohto problému môžu byť funkcie opísané v dolnom bloku.

Nebude tam však možné jednoducho preniesť celý funkčný kód, pretože potom bude porušené pravidlo: predtým, ako niečo použijete, musíte to deklarovať. Aby ste sa vyhli tomuto problému, musíte použiť prototyp funkcie.

Prototyp funkcie úplne zopakuje hlavičku funkcie, za ktorou nasleduje ; . Po zadaní prototypu v hornom bloku, v dolnom už môžeme plne opísať funkciu. Vo vyššie uvedenom príklade to môže vyzerať takto:

Výpis 6.

#include int max_num(int, int); int main(void) ( int x =0, y = 0; int m = 0; scanf("%d %d", &x, &y); m = max_num(x,y); printf("max(%d) ,%d) = %d\n",x,y,m); return 0; ) int max_num(int a, int b)( int max = b; if (a > b) max = a; return max; )

Všetko je veľmi jednoduché. Upozorňujeme, že prototyp funkcie nemusí špecifikovať názvy formálnych parametrov, stačí len uviesť ich typy. Vo vyššie uvedenom príklade som urobil presne to.