Argumenty funkce MAIN(). Jak funguje metoda main() v C

K čemu jsou funkce v C?

Funkce v C se používají k provádění specifických akcí v rámci obecného programu. Programátor sám rozhoduje, které akce se ve funkcích zobrazí. Obzvláště vhodné je použití funkcí pro opakované akce.

Jednoduchý příklad funkce v C

Příklad funkce v C:

#zahrnout #zahrnout int main(void) ( puts("Funkce v C"); return EXIT_SUCCESS; )

Jedná se o velmi jednoduchý C program. Jednoduše vytiskne řádek "Funkce v C". Program má jedinou funkci nazvanou main. Podívejme se na tuto funkci podrobně. V hlavičce funkce, tzn. v řadě

int je návratový typ funkce;

main je název funkce;

(void) je seznam argumentů funkce. Slovo void označuje, že funkce nemá žádné argumenty;

return je příkaz, který ukončí provádění funkce a vrátí výsledek funkce do bodu, ve kterém byla funkce volána;

EXIT_SUCCESS je hodnota rovna nule. Je definován v souboru stdlib.h;

část funkce za záhlavím, uzavřená ve složených závorkách

{
puts("Funkce v C");
return EXIT_SUCCESS;
}

se nazývá tělo funkce.

Když tedy pracujeme s funkcí, musíme uvést název funkce, pro nás je to hlavní, typ hodnoty vrácené funkcí, pro nás je to int, za znakem v závorce uveďte seznam argumentů jméno funkce, nemáme žádné argumenty, takže zapíšeme void, provedeme v těle funkce nějaké akce (kvůli kterým byla funkce vytvořena) a vrátíme výsledek funkce pomocí příkazu return. Zde jsou základy, které potřebujete vědět o funkcích v C.

Jak volat jinou funkci z jedné funkce v C?

Podívejme se na příklad volání funkcí v C:

/* Autor: @author Subbotin B.P..h> #include int main(void) ( puts("Funkce v C"); int d = 1; int e = 2; int f = suma(d, e); printf("1 + 2 = %d", f); return EXIT_SUCCESS;

Spustíme to a dostaneme:

Tento příklad vytvoří funkci součtu, která sečte dvě celá čísla a vrátí výsledek. Podívejme se podrobně na strukturu této funkce.

hlavička součtové funkce:

int součet (int a, int b)

zde int je návratový typ funkce;

součet je název funkce;

(int a, int b) - v závorce za názvem funkce je seznam jejích argumentů: první argument je int a, druhý argument je int b. Názvy argumentů jsou formální, tzn. Při volání funkce nemusíme posílat hodnoty proměnných pojmenovaných a a b jako argumenty této funkci. V hlavní funkci voláme součtovou funkci takto: sum(d, e);. Je však důležité, aby argumenty předané funkci odpovídaly typu deklarovanému ve funkci.

V těle součtové funkce, tzn. Uvnitř složených závorek za hlavičkou funkce vytvoříme lokální proměnnou int c, přiřadíme jí hodnotu součtu a plus b a vrátíme ji jako výsledek funkce s příkazem return.

Nyní se podívejme, jak se funkce součtu volá z hlavní funkce.

Zde je hlavní funkce:

Int main(void) ( puts("Funkce v C"); int d = 1; int e = 2; int f = suma(d, e); printf("1 + 2 = %d", f); return EXIT_SUCCESS;

Nejprve vytvoříme dvě proměnné int

Int d = 1;

int e = 2;

Předáme je součtové funkci jako hodnoty argumentů.

int f = suma(d, e);

int součet (int a, int b)

jeho hodnota bude výsledkem součtové funkce, tzn. zavoláme funkci součtu, která vrátí hodnotu typu int, kterou přiřadíme proměnné f. Předáme d a f jako argumenty. Ale v hlavičce funkce sum

argumenty se nazývají a a b, proč tedy předáme d a f? Protože v hlavičce funkce se zapisují formální argumenty, tzn. Názvy argumentů NEJSOU důležité, ale jejich typy jsou důležité. Funkce sum má oba argumenty typu int, což znamená, že při volání této funkce musíte předat dva argumenty typu int s libovolnými názvy.

Ještě jedna jemnost. Funkce musí být deklarována před jejím prvním voláním. V našem příkladu se stalo toto: nejprve je deklarována funkce součtu a teprve poté ji voláme z hlavní funkce. Pokud je funkce deklarována za místem, kde je volána, měl by být použit prototyp funkce.

Funkční prototyp v C

/* Autor: @author Subbotin B.P..h> #include Podívejme se na příklad funkce v C:

int suma(int a, int b);

int main(void) ( puts("Funkce v C"); int d = 1; int e = 2; int f = suma(d, e); printf("1 + 2 = %d", f); return EXIT_SUCCESS ) int suma(int a, int b) ( int c = 0; c = a + b; return c; )

V tomto příkladu je součtová funkce definována níže, kde je volána v hlavní funkci. V tomto případě musíte použít prototyp funkce součtu. Náš prototyp je deklarován nad hlavní funkcí:

Předáme je součtové funkci jako hodnoty argumentů.

a pod hlavní funkcí definujeme funkci součtu, která byla dříve deklarována v prototypu:

Int součet(int a, int b) ( int c = 0; c = a + b; návrat c; )

Jak se liší deklarace funkce v C od definice funkce v C?

Když píšeme prototyp funkce, například takto:

int main(void) ( puts("Funkce v C"); int d = 1; int e = 2; int f = suma(d, e); printf("1 + 2 = %d", f); return EXIT_SUCCESS ) int suma(int a, int b) ( int c = 0; c = a + b; return c; )

pak deklarujeme funkci.

A když implementujeme funkci, tzn. Zapisujeme nejen název, ale i tělo funkce, například:

Int součet(int a, int b) ( int c = 0; c = a + b; návrat c; )

pak definujeme funkci.

návratový výpis

Příkaz return ukončí funkci v C a vrátí výsledek její operace k bodu volání. Příklad:

Int součet(int a, int b) ( int c = 0; c = a + b; návrat c; )

Tuto funkci lze zjednodušit:

Int součet(int a, int b) ( return a + b; )

zde příkaz return vrátí hodnotu součtu a + b.

V jedné funkci může být několik příkazů return. Příklad:

Int sum(int a, int b) ( if(a > 2) ( return 0;// První případ; ) if(b< 0) { return 0;// Второй случай; } return a + b; }

Pokud je v příkladu hodnota argumentu a větší než dva, pak funkce vrátí nulu (první případ) a vše pod komentářem „// První případ;“ nebude provedena. Pokud je a menší než dva, ale b je menší než nula, pak funkce dokončí svou práci a vše pod komentářem „// Druhý případ;“ nebude provedena.

A pouze pokud nejsou splněny obě předchozí podmínky, pak provádění programu dosáhne posledního příkazu return a vrátí se součet a + b.

Předávání argumentů funkce hodnotou

Argumenty lze předávat funkci C podle hodnoty. Příklad:

/* Autor: @author Subbotin B.P..h> #include int sum(int a) ( return a += 5; ) int main(void) ( puts("Funkce v C"); int d = 10; printf("součet = %d\n", suma(d)) ; printf("d = %d", d);

V příkladu ve funkci main vytvoříme proměnnou int d = 10. Tuto proměnnou předáme hodnotou do funkce sum(d). Uvnitř součtové funkce se hodnota proměnné zvýší o 5. Ale v hlavní funkci se hodnota d nezmění, protože byla předána hodnotou. To znamená, že byla předána hodnota proměnné, nikoli samotná proměnná. Svědčí o tom výsledek programu:

těch. po návratu ze součtové funkce se hodnota d nezměnila, zatímco uvnitř součtové funkce ano.

Předávání ukazatelů C funkce

Pokud předáte ukazatel na tuto proměnnou jako argument funkci místo hodnoty proměnné, pak se hodnota této proměnné může změnit. Například převezmeme program z předchozí části a mírně jej změníme:

/* Autor: @author Subbotin B.P..h> #include int sum(int *a) ( return *a += 5; ) int main(void) ( puts("Funkce v C"); int d = 10; printf("součet = %d\n", sum(&d )); printf("d = %d", d);

V této verzi programu jsem přešel z předávání argumentu hodnotou na předávání ukazatele na proměnnou. Pojďme se na tento bod podívat blíže.

printf("soucet = %d\n", sum(&d));

To, co je předáno součtové funkci, není hodnota proměnné d rovna 10, ale adresa této proměnné, jako je tato:

Nyní se podívejme na funkci součtu:

Int součet(int *a) ( return *a += 5; )

Jeho argument je ukazatel na int. Víme, že ukazatel je proměnná, jejíž hodnota je adresa nějakého objektu. Adresa proměnné d je odeslána do funkce součtu:

Uvnitř součtu je ukazatel int *a dereferencován. To nám umožňuje přejít od ukazatele k samotné proměnné, na kterou ukazuje náš ukazatel. A v našem případě je to proměnná d, tzn. výraz

je ekvivalentní s výrazem

Výsledek: funkce součtu změní hodnotu proměnné d:

Tentokrát se hodnota d po návratu ze součtu změní, což nebylo dodrženo v předchozím odstavci, když jsme předali argument hodnotou.

C/C++ v Eclipse

Všechny příklady pro tento článek jsem vytvořil v Eclipse. Jak pracovat s C/C++ můžete vidět v Eclipse. Pokud pracujete v jiném prostředí, příklady budou fungovat i tam.

Štítky: Funkce v C, prototyp, popis, definice, volání. Formální parametry a skutečné parametry. Argumenty funkce, předávání hodnotou, předávání ukazatelem. Návratová hodnota.

Zavedení

Čím více studujeme C, tím větší jsou programy. Všechny akce shromažďujeme do jedné hlavní funkce a tytéž akce několikrát zkopírujeme, čímž vytvoříme desítky proměnných s jedinečnými názvy. Naše programy bobtnají a jsou čím dál méně srozumitelné, větve se prodlužují a větví.

Ale z této situace existuje cesta ven! Nyní se naučíme vytvářet funkce v C. Funkce zaprvé pomohou oddělit duplicitní kód do samostatných podprogramů, zadruhé pomohou logicky rozdělit program na části a zatřetí, funkce v C mají mnoho funkcí spojených s nimi, které umožní použití nových přístupů ke strukturování aplikací.

Funkce je pojmenovaná část programu, kterou lze opakovaně volat z jiné části programu (ve které je funkce viditelná). Funkce může mít pevný nebo proměnný počet argumentů nebo nemůže mít žádné argumenty. Funkce může buď vrátit hodnotu, nebo být prázdná (neplatná) a nevrací nic.

Mnoho funkcí již známe a víme, jak je volat - jsou to funkce knihoven stdio, stdlib, string, conio atd. Main je navíc také funkcí. Od ostatních se liší pouze tím, že je vstupním bodem při spouštění aplikace.
Funkce v C je definována v globálním kontextu. Syntaxe funkce: (, ...) ( )

Nejjednodušším příkladem je funkce, která vezme plovoucí číslo a vrátí druhou mocninu tohoto čísla

#zahrnout #zahrnout float sqr(float x) ( float tmp = x*x; return tmp; ) void main() ( printf("%.3f", sqr(9.3f)); getch(); )

Uvnitř funkce sqr jsme vytvořili lokální proměnnou, které byla přiřazena hodnota argumentu. Číslo 9.3 bylo předáno funkci jako argument. Servisní slovo return vrací hodnotu proměnné tmp. Funkci můžete přepsat následovně:

Float sqr(float x) ( return x*x; )

V tomto případě se nejprve provede násobení a poté se vrátí hodnota. Pokud funkce nic nevrátí, návratový typ bude neplatný. Například funkce, která vytiskne druhou mocninu čísla:

Void printSqr(float x) ( printf("%d", x*x); return; )

v tomto případě návrat znamená ukončení funkce. Pokud funkce nic nevrací, pak return není třeba psát. Poté funkce dokončí své dokončení a řízení se vrátí k volající funkci.

Void printSqr(float x) ( printf("%d", x*x); )

Pokud funkce nebere žádné argumenty, pak jsou závorky prázdné. Můžete také napsat slovo void:

Void printHelloWorld() ( printf("Ahoj světe"); )

ekvivalent

Void printHelloWorld(void) ( printf("Ahoj světe"); )

Formální a skutečné parametry

Při deklaraci funkce jsou specifikovány formální parametry, které jsou následně použity v rámci samotné funkce. Když voláme funkci, používáme skutečné parametry. Skutečnými parametry mohou být proměnné libovolného vhodného typu nebo konstanty.

Řekněme například, že existuje funkce, která vrací druhou mocninu čísla, a funkce, která sečte dvě čísla.

#zahrnout #zahrnout //Formální parametry mají jména a a b //pomocí nich přistupujeme k předávaným argumentům uvnitř funkce int sum(int a, int b) ( return a+b; ) float square(float x) ( return x*x; ) void main() ( //Skutečné parametry mohou mít libovolný název, včetně noname int one = 1; float two = 2.0; //Předejte proměnné, druhá proměnná je přetypována na požadovaný typ printf("%d\n" , sum(one, two) //Předávání číselných konstant printf("%d\n", sum(10, 20)); ("%d\n ", sum(10, 20.f) //Proměnná typu integer je převedena na typ s plovoucí desetinnou čárkou printf("%.3f\n", square(one)); Volání funkce lze také použít jako argument, který vrátí požadovanou hodnotu printf("%.3f\n", square(sum(2 + 4, 3)));

Vezměte prosím na vědomí, že přetypování probíhá implicitně a pouze tehdy, je-li to možné. Pokud funkce obdrží jako argument číslo, pak jí nelze předat proměnný řetězec, například "20" atd. Obecně je lepší vždy použít správný typ nebo typ explicitně přetypovat na požadovaný.
Pokud funkce vrátí hodnotu, nemusí být uložena. Použijeme například funkci getch, která přečte znak a vrátí jej.

#zahrnout #zahrnout void main() ( char c; do ( //Uložení návratové hodnoty do proměnné c = getch(); printf("%c", c); ) while(c != "q"); //Návrat hodnota není uložena getch();

Předávání argumentů

Při předávání argumentů se zkopírují. To znamená, že jakékoli změny, které funkce provede v proměnných, probíhají pouze v rámci funkce. Například

#zahrnout #zahrnout void change(int a) ( a = 100; printf("%d\n", a); ) void main() ( int d = 200; printf("%d\n", d); change(d) printf("%d", d);

Zobrazí se programy
200
100
200
Je jasné proč. Uvnitř funkce pracujeme s proměnnou x, která je kopií proměnné d. Změníme lokální kopii, ale samotná proměnná d se nezmění. Po ukončení funkce bude lokální proměnná zničena. Proměnná d se nijak nezmění.
Jak potom můžete změnit proměnnou? Chcete-li to provést, musíte předat adresu této proměnné. Přepišme funkci tak, aby akceptovala ukazatel typu int

#zahrnout #zahrnout void change(int *a) ( *a = 100; printf("%d\n", *a); ) void main() ( int d = 200; printf("%d\n", d); změna (&d); printf("%d", d);

Nyní výstupy programu
200
100
100
Zde byla také vytvořena lokální proměnná, ale jelikož byla adresa předána, změnili jsme hodnotu proměnné d pomocí její adresy v RAM.

V programování se první způsob předávání parametrů nazývá předávání hodnotou, druhý - předávání ukazatelem. Pamatujte na jednoduché pravidlo: pokud chcete změnit proměnnou, musíte funkci předat ukazatel na tuto proměnnou. Chcete-li tedy změnit ukazatel, musíte předat ukazatel na ukazatel atd. Napišme například funkci, která vezme velikost pole int a vytvoří ji. Na první pohled by funkce měla vypadat nějak takto:

#zahrnout #zahrnout #zahrnout void init(int *a, velikost bez znaménka) ( a = (int*) malloc(size * sizeof(int)); ) void main() ( int *a = NULL; init(a, 100); if (a = = NULL) ( printf("CHYBA"); ) else ( printf("V pořádku..."); free(a); ) getch();

Tato funkce však vydá ERROR. Předali jsme adresu proměnné. Uvnitř funkce init byla vytvořena lokální proměnná a, která ukládá adresu pole. Po ukončení funkce byla tato lokální proměnná zničena. Kromě toho, že jsme nemohli dosáhnout požadovaného výsledku, jsme objevili únik paměti: paměť byla alokována na haldě, ale již neexistuje proměnná, která by ukládala adresu této oblasti.

Chcete-li změnit objekt, musíte na něj předat ukazatel, v tomto případě ukazatel na ukazatel.

#zahrnout #zahrnout #zahrnout void init(int **a, velikost bez znaménka) ( *a = (int*) malloc(velikost * sizeof(int)); ) void main() ( int *a = NULL; init(&a, 100); if ( a == NULL) ( printf("CHYBA"); ) else ( printf("V pořádku..."); free(a); ) getch();

Nyní vše funguje jak má.
Další podobný příklad. Pojďme napsat funkci, která vezme řetězec jako argument a vrátí ukazatel na oblast paměti, do které byl tento řetězec zkopírován.

#zahrnout #zahrnout #zahrnout #zahrnout char* initByString(const char *str) ( char *p = (char*) malloc(strlen(str) + 1); strcpy(p, str); return p; ) void main() ( char *test = initByString( "Ahoj světe!"); printf("%s", test);

V tomto příkladu nedochází k nevracení paměti. Alokovali jsme paměť pomocí funkce malloc, zkopírovali jsme tam řetězec a pak vrátili ukazatel. Lokální proměnné byly odstraněny, ale testovací proměnná ukládá adresu části paměti na hromadu, takže ji lze odstranit pomocí funkce free.

Deklarace funkce a definice funkce. Vytvoření vlastní knihovny

V C můžete deklarovat funkci před jejím definováním. Deklarace funkce, její prototyp, se skládá z návratové hodnoty, názvu funkce a typu argumentů. Názvy argumentů lze vynechat. Například

#zahrnout #zahrnout //Prototypy funkcí. Názvy argumentů není třeba psát int odd(int); int sudý(int); void main() ( printf("pokud %d liché? %d\n", 11, liché(11)); printf("pokud %d liché? %d\n", 10, liché(10)); getch ( ) //Definice funkcí int sudá(int a) ( if (a) ( lichá(--a); ) else ( return 1; ) ) int lichá(int a) ( if (a) ( sudá(); - -a ) else ( návrat 0; ) );

Jedná se o smíšenou rekurzi – funkce lichá vrací 1, pokud je číslo liché, a 0, pokud je sudé.

Obvykle je deklarace funkce umístěna samostatně, v souboru .h, a definice funkcí v souboru .c. Hlavičkový soubor tedy představuje rozhraní knihovny a ukazuje, jak s ním pracovat, aniž byste se museli zabývat obsahem kódu.

Vytvoříme jednoduchou knihovnu. K tomu budete muset vytvořit dva soubory – jeden s příponou .h a umístit tam prototypy funkcí a druhý s příponou .c a umístit tam definice těchto funkcí. Pokud pracujete s IDE, musí být soubor .h vytvořen ve složce Header Files a soubory kódu ve složce Source Code Files. Nechť se soubory jmenují File1.ha File1.c
Přepišme předchozí kód. Takto bude vypadat hlavičkový soubor File1.h

#ifndef _FILE1_H_ #define _FILE1_H_ int odd(int); int sudý(int); #endif

Obsah souboru zdrojového kódu File1.c

#include "File1.h" int sudé(int a) ( if (a) ( liché(--a); ) else ( return 1; ) ) int liché(int a) ( if (a) ( sudé(-- a); ) else ( návrat 0; ) )

Naše hlavní funkce

#zahrnout #zahrnout #include "File1.h" void main() ( printf("if %d liché? %d\n", 11, liché(11)); printf("if %d liché? %d\n", 10, lichý(10));

Podívejme se na vlastnosti každého souboru. Náš soubor, který obsahuje hlavní funkci, obsahuje knihovny, které potřebuje, a také hlavičkový soubor File1.h. Kompilátor nyní zná prototypy funkcí, to znamená, že zná návratový typ, počet a typ argumentů a názvy funkcí.

Soubor záhlaví, jak bylo uvedeno výše, obsahuje prototyp funkce. Zde lze také zahrnout použité knihovny. Ochrana maker #define _FILE1_H_ atd. slouží k zabránění opětovnému kopírování kódu knihovny během kompilace. Tyto řádky lze nahradit jedním

#pragma Once int odd(int); int sudý(int);

Soubor zdrojového kódu File1.c obsahuje soubor záhlaví. Vše je logické a jednoduché jako obvykle. V hlavičkových souborech je kromě prototypů funkcí běžné zahrnout konstanty, substituce maker a definovat nové datové typy. Navíc právě v hlavičkových souborech můžete kód obsáhle komentovat a psát příklady jeho použití.

Předání pole jako argumentu

Jak již bylo zmíněno dříve, název pole je nahrazen ukazatelem, takže předání jednorozměrného pole je ekvivalentní předání ukazatele. Příklad: funkce přijme pole a jeho velikost a vypíše:

#zahrnout #zahrnout void printArray(int *arr, velikost bez znaménka) ( bez znaménka i; pro (i = 0; i< size; i++) { printf("%d ", arr[i]); } } void main() { int x = {1, 2, 3, 4, 5}; printArray(x, 10); getch(); }

V tomto příkladu může funkce vypadat takto

Void printArray(int arr, velikost bez znaménka) ( i bez znaménka; for (i = 0; i< size; i++) { printf("%d ", arr[i]); } }

Dovolte mi také připomenout, že pravidlo pro nahrazení pole ukazatelem není rekurzivní. To znamená, že při přenosu je nutné zadat rozměr dvourozměrného pole

#zahrnout #zahrnout void printArray(int arr, velikost bez znaménka) ( bez znaménka i, j; for (i = 0; i< size; i++) { for (j = 0; j < 5; j++) { printf("%d ", arr[i][j]); } printf("\n"); } } void main() { int x = { { 1, 2, 3, 4, 5}, { 6, 7, 8, 9, 10}}; printArray(x, 2); getch(); }

Nebo můžete napsat

#zahrnout #zahrnout void printArray(int (*arr), velikost bez znaménka) ( bez znaménka i, j; for (i = 0; i< size; i++) { for (j = 0; j < 5; j++) { printf("%d ", arr[i][j]); } printf("\n"); } } void main() { int x = { { 1, 2, 3, 4, 5}, { 6, 7, 8, 9, 10}}; printArray(x, 2); getch(); }

Pokud je dvourozměrné pole vytvořeno dynamicky, můžete předat ukazatel na ukazatel. Například funkce, která vezme pole slov a vrátí pole celých čísel rovných délce každého slova:

#zahrnout #zahrnout #zahrnout #zahrnout #define SIZE 10 unsigned* getLengths(const char **slova, velikost bez znaménka) ( unsigned *lengths = NULL; unsigned i; lengths = (unsigned*) malloc(size * sizeof(unsigned)); for (i = 0; i< size; i++) { lengths[i] = strlen(words[i]); } return lengths; } void main() { char **words = NULL; char buffer; unsigned i; unsigned *len = NULL; words = (char**) malloc(SIZE * sizeof(char*)); for (i = 0; i < SIZE; i++) { printf("%d. ", i); scanf("%127s", buffer); words[i] = (char*) malloc(128); strcpy(words[i], buffer); } len = getLengths(words, SIZE); for (i = 0; i < SIZE; i++) { printf("%d ", len[i]); free(words[i]); } free(words); free(len); getch(); }

Namísto vracení ukazatele na pole můžete předat pole, které je třeba vyplnit

#zahrnout #zahrnout #zahrnout #zahrnout #define SIZE 10 void getLengths(const char **slova, velikost bez znaménka, unsigned *out) ( unsigned i; for (i = 0; i< size; i++) { out[i] = strlen(words[i]); } } void main() { char **words = NULL; char buffer; unsigned i; unsigned *len = NULL; words = (char**) malloc(SIZE * sizeof(char*)); for (i = 0; i < SIZE; i++) { printf("%d. ", i); scanf("%127s", buffer); words[i] = (char*) malloc(128); strcpy(words[i], buffer); } len = (unsigned*) malloc(SIZE * sizeof(unsigned)); getLengths(words, SIZE, len); for (i = 0; i < SIZE; i++) { printf("%d ", len[i]); free(words[i]); } free(words); free(len); getch(); }

Zde první seznámení s funkcemi končí: téma je velmi rozsáhlé a je rozděleno do více článků.

Při vytváření konzolové aplikace v programovacím jazyce C++ se automaticky vytvoří řádek velmi podobný tomuto:

Int main(int argc, char* argv) // parametry funkce main().

Tento řádek je hlavičkou hlavní funkce main(), parametry argс a argv jsou deklarovány v závorkách. Pokud tedy spouštíte program přes příkazový řádek, je možné do tohoto programu přenést některé informace, k tomu jsou zde parametry argc a argv. Parametr argc má datový typ int a obsahuje počet parametrů předávaných hlavní funkci. Navíc argc je vždy alespoň 1, i když nepředáváme žádné informace, protože prvním parametrem je název funkce. Parametr argv je pole ukazatelů na řetězce. Přes příkazový řádek lze předávat pouze data řetězce. Ukazatele a řetězce jsou dvě velká témata, pro která byly vytvořeny samostatné sekce. Veškeré informace jsou tedy přenášeny prostřednictvím parametru argv. Pojďme si vyvinout program, který spustíme přes příkazový řádek Windows a předáme mu nějaké informace.

// argc_argv.cpp: Definuje vstupní bod pro konzolovou aplikaci. #include "stdafx.h" #include pomocí jmenného prostoru std; int main(int argc, char* argv) ( if (argc ><< argv<

// kód Kód::Blocks

// Kód Dev-C++

// argc_argv.cpp: Definuje vstupní bod pro konzolovou aplikaci. #zahrnout pomocí jmenného prostoru std; int main(int argc, char* argv) ( if (argc > 1) // pokud předáme argumenty, pak argc bude větší než 1 (v závislosti na počtu argumentů) ( cout<< argv<

Po odladění programu otevřete příkazový řádek Windows a přetáhněte spustitelný soubor našeho programu do okna příkazového řádku Úplná cesta k programu se zobrazí v příkazovém řádku (cestu k programu však můžete zadat ručně ), na které můžete kliknout ENTER a program se spustí (viz obrázek 1).

Obrázek 1 - Hlavní funkční parametry

Protože jsme program jednoduše spustili a nepředali jsme mu žádné argumenty, objevila se zpráva Not arguments. Obrázek 2 ukazuje spuštění stejného programu přes příkazový řádek, ale předání mu argumentu Open.

Obrázek 2 - Hlavní funkční parametry

Argumentem je slovo Open, jak je vidět z obrázku, toto slovo se objevilo na obrazovce. Můžete předat několik parametrů najednou a oddělit je čárkou. Pokud potřebujete předat parametr skládající se z několika slov, pak musí být uzavřena do dvojitých uvozovek a pak budou tato slova považována za jeden parametr. Obrázek například ukazuje spuštění programu, který mu předá argument sestávající ze dvou slov - Funguje to.

Obrázek 3 - Hlavní funkční parametry

A pokud odstraníte uvozovky. Pak uvidíme pouze slovo To. Pokud neplánujete při spuštění programu předávat žádné informace, můžete odstranit argumenty ve funkci main() a také můžete změnit názvy těchto argumentů. Někdy se setkáme s úpravami parametrů argc a argv, ale to vše závisí na typu vytvářené aplikace nebo na vývojovém prostředí.

Základní forma zápisu funkce je následující

návratový_typ název_funkce(seznam_parametrů) { funkce těla) Typ dat vrácených funkcí je určen pomocí prvku návratový_typ . Pod prvkem seznam_parametrů znamená čárkami oddělený seznam proměnných, které mohou převzít jakékoli argumenty předané funkcí.

Pokud v C89 není datový typ vrácený funkcí explicitně specifikován, předpokládá se typ int. V C++ a C99 není výchozí typ int podporován, ačkoli většina kompilátorů C++ tento předpoklad stále předpokládá.

Funkční prototypy

V jazyce C++ musí mít všechny funkce prototypy a v jazyce C jsou prototypy formálně volitelné, ale vysoce žádoucí. Obecná forma definice prototypu je následující.

návratový_typ název_funkce(seznam_parametrů); Například. float fn(float x); //nebo float fn(float);

V C se místo seznamu parametrů používá klíčové slovo void k určení prototypu funkce, která nemá žádné parametry. V C++ prázdný seznam parametrů v prototypu funkce znamená, že funkce nemá žádné parametry. Slovo neplatný je v tomto případě nepovinné.

Vrácení hodnot (příkaz return)

Vrácení hodnot ve funkcích se provádí pomocí příkazu return. má dvě formy zápisu.

Návrat; návrat význam;

V C99 a C++ by se forma příkazu return, která neurčuje návratovou hodnotu, měla používat pouze ve funkcích void.

Přetížení funkcí

V C++ mohou funkce přetížení. Když se říká, že funkce je přetížená, znamená to, že dvě nebo více funkcí mají stejný název, ale každá verze přetížené funkce má jiný počet nebo typ parametrů. Zvažte příklad následujících tří přetížených funkcí.

Void func (int a)( cout

V každém případě se analyzuje typ a počet argumentů, aby se určilo, která verze funkce func() bude volána.

Předávání argumentů výchozí funkce

V C++ lze parametru funkce přiřadit výchozí hodnotu, která se automaticky použije, pokud při volání funkce není zadán odpovídající argument. Například.

Void func (int a = 0, int b = 10)() //volání func(); func(-1); func(-1,99);

Rozsah a životnost proměnných.

Jazyky C a C++ definují pravidla viditelnosti, která zavádějí pojmy, jako je rozsah a životnost objektů. Existuje globální a lokální rozsah.

Globální obor existuje mimo všechny ostatní obory. Název deklarovaný v globálním rozsahu zná celý program. Například globální proměnná je k dispozici pro použití všemi funkcemi programu. Globální proměnné existují po celý životní cyklus programu.

Místní rozsah je určen hranicemi bloku. Název deklarovaný v místním rozsahu je znám pouze v tomto rozsahu. Lokální proměnné jsou vytvořeny při vstupu do bloku a zničeny při opuštění bloku. To znamená, že lokální proměnné neukládají své hodnoty mezi volání funkcí. Chcete-li zachovat proměnné hodnoty mezi voláními, můžete použít statický modifikátor.

Rekurze

V C a C++ mohou funkce volat samy sebe. Tento proces se nazývá rekurze a funkce, která volá sama sebe, je rekurzivní. Jako příklad se podívejme na funkci fact(), která počítá faktoriál celého čísla.

Int fact (int n) ( int ans; if (n == 1) return 1; ans = fact (n-1) * n; return ans; )

funkce main().

Provádění programu v C/C++ začíná provedením funkce main(). (Programy Windows volají funkci WinMain());

Funkce main() nemá žádný prototyp. Proto lze použít různé formy funkce main(). Následující varianty funkce main() jsou platné pro C i C++.

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

Jak je vidět z druhé formy záznamu, f. main() přijímá alespoň dva parametry. Říká se jim argc a argv. Tyto argumenty budou uchovávat počet argumentů příkazového řádku a ukazatel na ně. argc je celočíselný typ a jeho hodnota bude vždy alespoň 1, protože stejně jako v C a C++ je prvním argumentem vždy název programu. Parametr argv musí být deklarován jako pole ukazatelů znaků, přičemž každý prvek ukazuje na argument příkazového řádku. Níže je uveden příklad programu, který ukazuje použití těchto argumentů.

#zahrnout pomocí jmenného prostoru std; int main (int argc, char *argv) ( if (argc

Předávání ukazatelů

I když jazyky C a C++ ve výchozím nastavení používají předávání parametru hodnotou, můžete ručně vytvořit volání f. s předáním parametrů odkazem. Chcete-li to provést, musíte předat ukazatel na argument. Protože v tomto případě je funkce předána adresa argumentu, Ukazuje se, že je možné změnit hodnotu argumentu mimo funkci. Například.

Void swap (int *x, int *y) ( int temp; temp = *x; ​​​​*x = *y; *y = temp; ) //swap hovoru (&a, &b);

V C++ může být adresa proměnné předána funkci automaticky. Toto je implementováno pomocí referenční-parametr. Při použití referenčního parametru je funkce předána adresa argumentu a funkce pracuje s argumentem spíše než s kopií. Chcete-li vytvořit parametr odkazu, musíte před jeho název uvést ampersand (&). Uvnitř f. tento parametr lze použít normálně, například bez použití operátoru hvězdička (*).

Void swap (int &x, int &y)( int temp; temp = x; x = y; y = temp; ) //call swap (a, b);

Specifikátory funkcí

C++ definuje tři specifikátory funkcí:

• inline
• virtuální
• explicitní

Inline specifikátor je požadavek na kompilátor: namísto vytvoření volání funkce rozbalte její kód přímo na řádku. Pokud kompilátor nemůže vložit funkci do řetězce, má právo tento požadavek ignorovat. Inline specifikátor může definovat členské funkce i nečlenské funkce.

Jako virtuální funkce (pomocí virtuálního specifikátoru) f. je definována v základní třídě a přepsána v odvozené třídě. Pomocí virtuálních funkcí jako příkladu můžete pochopit, jak jazyk C++ podporuje polymorfismus.

Explicitní specifikátor se vztahuje pouze na konstruktory Konstruktor definovaný jako explicitní bude použit pouze v případě, že inicializace přesně odpovídá tomu, co je specifikováno konstruktorem. Nebudou prováděny žádné konverze (tj. explicitní specifikátor vytvoří "nekonvertující konstruktor").

Šablony funkcí

Obecná forma definování funkce šablony je následující.

Typ šablony> návratový_typ název_funkce (seznam_parametrů) ( //tělo funkce ) Zde typ znamená zástupný štítek pro typ dat, se kterými bude tato funkce skutečně pracovat. V příkazu šablony můžete definovat více parametrů datového typu pomocí formuláře seznamu prvků oddělených čárkami.

Podívejme se na příklad.

Šablona void swap (X &a, X &b) (X temp; temp = a; a = b; b = temp; ) //volání int a, b; plovoucí x, y; swap(a, b); swap(x, y);

Ukazatele funkcí

Můžete vytvořit ukazatel na funkci, jako na jakýkoli jiný objekt jazyka C. Syntaxe je následující.

návratový_typ (*index_name)(popis proměnné); Tato deklarace vytvoří ukazatel na volanou funkci index_name , který obsahuje proměnné popis proměnné a která vrací hodnotu typu návratový_typ .

Funkci lze volat pomocí ukazatele následovně.

index_name = název_funkce; variabilní = index_name (proměnné); Zde první řádek vytváří odkaz na funkci název_funkce. Druhý řádek ve skutečnosti volá funkci přes ukazatel index_name , kterému se předávají proměnné proměnné, hodnota je vrácena do proměnné variabilní .

Následující příklad ukazuje vytvoření ukazatele a dva způsoby volání funkce prostřednictvím ukazatele a také předání funkce jako parametru jiným funkcím.

dvojité y; double (*p)(doublr x); p = hřích; //vytvoření ukazatele na funkci sin() y = (*p)(2.5); //volání y = p(2,5); //volání //předání funkce jako parametru double y; double f(double (*c)(double x), double y)( return c(y); //zavolání předané funkce na ukazatel c a vrátí hodnotu ) y = f(sin, 2,5); //předá funkci sin funkci f a také parametr, který bude zpracován

Můžete také vytvořit pole ukazatelů funkcí.

Int f1(void); int f2(void); int f3(void); int (*p)(void) = (f1, f2, f3) y = (*p)(); //volání funkce f2 y = p(); //volání funkce f3

Funkce hlavní.

Každý program v C a C++ musí mít hlavní funkci;<значение>toto je hodnota dané proměnné prostředí, například C:\DOS;C:\TOOLS (pro PATH) nebo YES (pro 87). #zahrnout Pamatujte však, že pokud zadáte některé z těchto argumentů, musíte je zadat v tomto pořadí: argc, argv, env. Platné jsou například následující deklarace argumentů: main() main(int argc) /* platné, ale ne příliš dobré */ main(int argc, char *argv) main(int argc, char *argv, char *env) Main (int) deklarace argc) není příliš pohodlné, protože při znalosti počtu parametrů k nim sami nemáte přístup.<=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 with blanks" 3 4 "last but one" stop! Komentář. Pokud chcete, aby zpracování escape znaků probíhalo vždy, tzn. Chcete-li mít WILDARGS.OBJ automaticky propojený editorem odkazů, musíte upravit svou standardní knihovnu C?.LIB tak, aby zahrnovala soubor WILDARGS.OBJ. Chcete-li to provést, odeberte SETARGV z knihovny a přidejte WILDARGS. To lze provést pomocí následujících příkazů (předpokládáme, že standardní knihovny a WILDARGS.OBJ jsou obsaženy v aktuálním adresáři): TLIB je popsán v kapitole 7, Nástroje, uživatelské příručky tlib cs -setargv +wildargs tlib cc -. setargv +wildargs tlib cm -setargv +wildargs tlib cl -setargv +wildargs tlib ch -setargv +wildargs Kompilace pomocí přepínače -p (konvence volání Pascalu) Pokud svůj program kompilujete pomocí konvence volání Pascalu (podrobně popsané v konvenci volání Pascalu Kapitola 9 "Rozhraní s jazykem symbolických instrukcí", "Programmer's Guide"), musíte mít na paměti, že funkce main musí být explicitně deklarována jako funkce C. To lze provést pomocí klíčového slova cdecl: cdecl main(int argc , char *argv, char *env) Hodnota vrácená funkcí main.