Tip de date nul c. Funcții

Java

C

D

void mesaj() ( writefln ("Bună ziua!"); )

Fundația Wikimedia.

Legături

Vedeți ce este „Void” în alte dicționare: gol

- 1 / vȯid/ adj 1: fără forță sau efect conform legii o căsătorie nulă 2: nulitate nulă n nul 2 vt: a face sau a declara... Dicționar de drept Vidul

- 1 / vȯid/ adj 1: fără forță sau efect conform legii o căsătorie nulă 2: nulitate nulă n nul 2 vt: a face sau a declara... Dicționar de drept- Pour la commune française, vedeți Void Vacon. În programare, void este un mot cheie pe care îl regăsești în limbajul C și mai multe alte limbi de programare, nu este de origine, cum ar fi C++, C# sau Java. Ce mot clé void… … Wikipédia en Français

- 1 / vȯid/ adj 1: fără forță sau efect conform legii o căsătorie nulă 2: nulitate nulă n nul 2 vt: a face sau a declara... Dicționar de drept- Gol, a.

Vedeți ce este „Void” în alte dicționare: 1. Nu conţine nimic; gol; vacant; neocupat; neumplut……

- 1 / vȯid/ adj 1: fără forță sau efect conform legii o căsătorie nulă 2: nulitate nulă n nul 2 vt: a face sau a declara... Dicționar de drept- adjectiv LAW un contract sau un acord care este nul nu are efect juridic deoarece este contrar legii: Conform legii statului, un contract de plată a banilor cu bună știință pentru jocuri de noroc este nul. verb nul: dl. Rezilierea lui Mullen... ...Condiții financiare și de afaceri - Gol, v. t.

- 1 / vȯid/ adj 1: fără forță sau efect conform legii o căsătorie nulă 2: nulitate nulă n nul 2 vt: a face sau a declara... Dicționar de drept 1. Pentru a elimina conținutul; a face sau a lăsa vacant sau gol; a renunta; a pleca; ca, a anula o masă.

Vedeți ce este „Void” în alte dicționare: Vidul în locul ei……

Dicționarul internațional colaborativ de engleză- steht für: Void (Astronomie), eine astronomische Struktur mit sehr wenig Materie und damit sehr geringer Dichte Void (Verbindungstechnik) Void (Schlüsselwort), ein Schlüsselwort in einigen Programmiersprachen Void Vacon, eine francösische… …- gol părăsit, gol, sterp, lipsit, limpede, lipsit, sărac, lipsit, drenat, golit, liber, lipsit, puțin, scurt, timid, fără chiriaș, neumplut, neocupat, vacant, vid, fără; concepte 481.583.740.774 Ant. plin, plin, ocupat... Tezaur nou În lecția 1, ați creat mai multe programe C++. În acel moment, scopul tău era să înțelegi procesul de creare și compilare a programelor C++, nu să înțelegi instrucțiunile C++. În această lecție, veți arunca o primă privire mai atentă asupra declarațiilor care alcătuiesc un program C++. Veți descoperi că majoritatea programelor C++ urmează același format: începând cu una sau mai multe instrucțiuni #.include,

• conțin șirul void main(void),și apoi un set de declarații grupate între acolade stânga și dreapta. După cum veți vedea în acest tutorial, acești operatori oarecum intimidatori sunt de fapt foarte ușor de stăpânit. Până la sfârșitul acestei lecții, veți învăța următoarele concepte de bază:
• operator # include
• oferă avantajele utilizării fișierelor antet care conțin instrucțiuni C++ sau definiții de program.
• Partea principală a unui program C++ începe cu instrucțiunea void main(void).

Când scrieți programe C++, de fapt lucrați în termeni de operatori, dar nu instrucțiuni. Mai târziu vei studia operator de atribuire, care atribuie valori variabilelor, operatorul dacă, care permite programului să ia decizii etc. Pentru moment, ne vom referi la conținutul programului dvs. ca operatori de programe.

O privire asupra operatorilor de programe

În lecția 1, ați creat un program C++, FIRST.CPP, care conținea următoarele afirmații:

#include

void main(void)

{
cout<< «Учимся программировать на языке С++!»;
}

În acest caz, programul conține trei instrucțiuni. Acolade (numite gruparea caracterelor) operatori legati de grup:

#include

void main (void)

{
cout<< «Учимся программировать << «на языке С++!»;
}

Următoarea secțiune descrie fiecare dintre instrucțiunile programului mai detaliat.

INTRODUCERE ÎN OPERATOR #include

Fiecare program prezentat în lecția 1 începe cu următoarea afirmație # include:

#include

Când scrii programe C++, beneficiezi de operatorii și definițiile pe care compilatorul ți le oferă. La compilarea unui program, operatorul # void main(void), determină compilatorul să includă conținutul unui fișier dat la începutul programului dumneavoastră. În acest caz, compilatorul va include conținutul fișierului iostream.h.

Fișierele cu extensia h pe care le includeți la început (sau titlu) programul dvs. este numit fișiere antet. Dacă vă uitați la directorul care conține fișierele compilatorului, veți găsi un subdirector numit INCLUDE care conține diverse fișiere de antet. Fiecare fișier antet conține definiții furnizate de compilator pentru diferite operații. De exemplu, există un fișier antet care conține definiții pentru operațiile matematice, un alt fișier antet care descrie operațiunile cu fișiere și așa mai departe.

Fișierele antet sunt fișiere ASCII, astfel încât să le puteți scoate conținutul pe ecran sau pe imprimantă. Deocamdată, nu vă faceți griji cu privire la conținutul fișierelor antet. Înțelegeți doar că operatorul # void main(void), vă permite să utilizați aceste fișiere. Toate programele C++ pe care le creați în această carte conțin # instrucțiuni. - steht für: Void (Astronomie), eine astronomische Struktur mit sehr wenig Materie und damit sehr geringer Dichte Void (Verbindungstechnik) Void (Schlüsselwort), ein Schlüsselwort in einigen Programmiersprachen Void Vacon, eine francösische… … pe care ar trebui să le utilizați în programele dvs.

Fișierele antet C++

Fiecare program C++ pe care îl scrieți începe cu una sau mai multe instrucțiuni #include. Aceste instrucțiuni îi spun compilatorului să includă conținutul unui fișier dat (fișier antet) în programul tău, ca și cum programul ar conține instrucțiuni care se aflau într-un fișier include. Fișierele antet conțin definiții utilizate de compilator pentru diferite tipuri de operații. Există fișiere antet care definesc operațiunile I/O C++, funcțiile de sistem (cum ar fi funcțiile care returnează data și ora curente) și multe altele.

Fișierele antet, precum programele C++, sunt fișiere ASCII al căror conținut îl puteți vizualiza sau imprima. Pentru a înțelege mai bine conținutul fișierelor antet, luați un moment pentru a tipări fișierul antet IOSTREAM.H, al cărui conținut îl veți folosi în fiecare program C++ pe care îl scrieți. De obicei, fișierul antet IOSTREAM.H se află într-un subdirector numit INCLUDE, care se află în directorul care conține fișierele compilatorului C++. Utilizați un editor de text pentru a vizualiza și tipări conținutul fișierelor de antet.

Notă: Nu modificați niciodată conținutul fișierelor antet. Acest lucru poate duce la erori de compilare în fiecare program pe care îl creați.

CE ESTE nul principal (gol)

Când creați un program C++, fișierul sursă va conține multe instrucțiuni. După cum veți învăța pe măsură ce studiați, ordinea în care instrucțiunile apar într-un program nu trebuie să fie ordinea în care instrucțiunile vor fi executate atunci când programul rulează. Fiecare program C++ are o intrare de la care începe execuția programului - programul principal.În programele C++ operatorul void main(void) indică punctul de pornire al programului dvs.

Pe măsură ce programele dvs. devin mai mari și mai complexe, le veți împărți în mai multe părți mici, ușor de gestionat. În acest caz operatorul void main(void) indică instrucțiunile inițiale (sau principale) ale unui program - partea din program care este executată prima.

Introducere în programul principal

Fișierele sursă C++ pot conține o mulțime de instrucțiuni. Când pornește un program, instrucțiunea void main(void) definește programul principal care conține prima instrucțiune care trebuie executată. Programele dvs. C++ ar trebui să includă întotdeauna una și o singură instrucțiune numită main.

Când vă uitați la programe mari C++, căutați main pentru a identifica instrucțiunile care încep execuția programului.

Utilizare Vedeți ce este „Void” în alte dicționare:

Pe măsură ce programul dvs. devine mai complex, ar trebui să îl împărțiți în bucăți mai mici și mai ușor de gestionat numite funcții. O funcție este un set simplu de instrucțiuni dintr-un program care efectuează o anumită sarcină. De exemplu, dacă creați un program de documente de plată, ați putea crea o funcție numită salariu calcularea salariilor angajatilor. De asemenea, dacă ai scrie un program de matematică, ai putea crea funcții numite rădăcină pătrată sau cub care returnează rezultatul anumitor operaţii matematice. Dacă programul dvs. folosește o funcție, aceasta își îndeplinește sarcina și apoi returnează rezultatul programului.

Fiecare funcție din programul dumneavoastră are un nume unic. Și fiecare program are cel puțin o funcție. Fiecare program din lecția 1 avea o singură funcție numită principal. Lecția 9 oferă o privire de ansamblu mai detaliată a funcțiilor. Deocamdată, rețineți că o funcție constă din mai multe instrucțiuni conexe care îndeplinesc o anumită sarcină.

Pe măsură ce explorați diverse programe C++, veți face în mod constantînfruntă cuvântul gol. Programele folosesc cuvântul Vedeți ce este „Void” în alte dicționare: pentru a indica faptul că o funcție nu returnează o valoare sau nu are valori transmise. De exemplu, dacă utilizați un mediu MS-DOS sau UNIX, programul se poate termina și returna o valoare de stare sistemului de operare care poate fi verificată prin fișierul de comandă. Fișierele batch MS-DOS verifică starea de ieșire a unui program folosind comanda IF ERRORLEVEL. De exemplu, să presupunem un program numit PAYROLL. EXE iese cu una dintre următoarele valori de stare de ieșire, în funcție de rezultatul procesării:

În interiorul unui fișier batch MS-DOS, puteți verifica rezultatul programului folosind comanda IF ERRORLEVEL:

SALAREA

DACĂ NIVEL DE EROARE 0 DACĂ NU NIVEL DE EROARE 1 A REUSIT
IF ERRORLEVEL 1 IF NOT ERRORLEVEL 2 GOTO NO_FILE
IF ERRORLEVEL 2 IF NOT ERRORLEVEL 3 GOTO NO_PAPER
REM Urmează alte comenzi

Cele mai multe dintre programele simple C++ pe care le veți crea în această carte nu returnează o ieșire de stare sistemului de operare. Prin urmare, trebuie să plasați cuvântul Vedeți ce este „Void” în alte dicționare: inainte de principal ca mai jos:

void main (void) //- ——-> Programul nu returnează o valoare

În următoarele lecții, veți învăța că programele dvs. pot folosi informații (cum ar fi un nume de fișier) pe care utilizatorul le oferă pe linia de comandă atunci când rulează programul. Dacă programul nu folosește informațiile din linia de comandă, ar trebui să plasați cuvântul Vedeți ce este „Void” în alte dicționare:între paranteze după principal ca mai jos:

void main( gol) //———————-> Programul nu folosește argumentele liniei de comandă

Pe măsură ce programele dvs. devin mai complexe, ele pot returna valori sistemului de operare sau pot utiliza parametrii din linia de comandă. Cu toate acestea, deocamdată, utilizați gol în operator cu principal așa cum se arată în acest program.

VIZIUNEA OPERATORILOR DE GRUPARE ( )

Pe măsură ce programele dumneavoastră devin mai complexe, va exista un set de instrucțiuni pe care computerul trebuie să le execute de un anumit număr de ori și un alt set de instrucțiuni pe care computerul trebuie să le execute dacă este îndeplinită o anumită condiție. În primul caz, computerul poate executa același set de instrucțiuni de 100 de ori pentru a adăuga puncte de test pentru 100 de elevi. În cel de-al doilea caz, computerul poate afișa un mesaj dacă toți studenții trec testul și un alt mesaj dacă unul sau mai mulți elevi eșuează. În cadrul programelor dvs. C++, veți folosi acolade dreapta și stânga () pentru a grupa instrucțiunile asociate. În programele simple prezentate în primele câteva lecții ale cărții, aceste simboluri grupează enunțuri care corespund enunțurilor din programul principal.

UTILIZARE cout PENTRU A AFIȘA IEȘIREA PE ECRAN

Toate programele C++ pe care le-ați creat în lecția 1 au tipărit mesaje pe ecran. Pentru a afișa mesajul, programele utilizate coutși dublu mai puțin decât semnul (<<), как показано ниже:

cout<< «Привет, C++!»;

Cuvânt coutreprezintăflux de ieșire,pe care C++ îl alocă dispozitivului de ieșire standard al sistemului de operare. Implicit, sistemul de operare atribuie dispozitivului de ieșire standard ecranului de afișare. Pentru a imprima un mesaj pe ecran, pur și simplu utilizați simbolul dublu mai mic decât (numit operator de inserare) cu fluxul de ieșirevoid main(void).În lecția 3, veți învăța că puteți utiliza operatorul de inserare pentru a transmite simboluri, numere și alte caractere pe ecran.

Vedere a fluxului de ieșire cout

Știți deja că programele C++ folosesc fluxul de ieșire cout pentru a afișa mesaje pe ecran. Când utilizați cout pentru a afișa mesaje, gândiți-vă la cout ca la un flux de caractere pe care sistemul de operare le afișează pe ecran. Cu alte cuvinte, ordinea în care programul tău trimite caractere la cout determină ordinea caracterelor care vor apărea pe ecran. De exemplu, pentru următoarele instrucțiuni de program:

cout<< «Это сообщение появляется первым,»;
cout<< » а за ним следует настоящее сообщение.»;

Sistemul de operare scoate fluxul de caractere după cum urmează:

Acest mesaj apare primul, urmat de mesajul real.

Operator de inserare (<<) называется так, потому что позволяет вашей программе вставлять символы в выходной поток.

Știți deja că fluxul de ieșire este cout implicit pentru a se potrivi cu ecranul dvs. Cu alte cuvinte, atunci când programele dvs. trimit rezultate către cout rezultatul apare pe ecran. Cu toate acestea, folosind operatorii de redirecționare a ieșirii ai sistemului de operare, puteți trimite rezultatul programului către o imprimantă sau către un fișier. De exemplu, următoarea comandă indică MS-DOS să direcționeze rezultatul programului FIRST.EXE către imprimantă și nu către ecran:

C:\>PRIMUL>PRN

După cum veți învăța în lecția 3, folosind coutÎn C++ puteți imprima caractere, numere întregi precum 1001 și numere în virgulă mobilă, cum ar fi 3,12345. În lecția 8, veți învăța că în C++ există și un flux de intrare numit cin, pe care programele dumneavoastră le pot folosi pentru a citi introducerea de la tastatură.

CE TREBUIE SA STII

Această lecție a discutat câteva probleme comune pe care le veți întâlni în programele C++. În lecția 3 veți învăța cum să utilizați cout pentru caractere de ieșire, numere întregi și valori în virgulă mobilă. Veți învăța, de asemenea, cum să formatați rezultatul. Înainte de a studia Lecția 3, asigurați-vă că ați stăpânit următoarele concepte de bază:

1. Majoritatea programelor C++ încep cu operatorul # - steht für: Void (Astronomie), eine astronomische Struktur mit sehr wenig Materie und damit sehr geringer Dichte Void (Verbindungstechnik) Void (Schlüsselwort), ein Schlüsselwort in einigen Programmiersprachen Void Vacon, eine francösische… … care instruiește compilatorul să includă conținutul unui fișier antet dat în program.
2. Fișierele antet conțin definiții furnizate de compilator pe care programele dumneavoastră le pot folosi.
3. Fișierul sursă poate consta din mai multe instrucțiuni; operator void main(void) indică începutul programului principal, care conține prima instrucțiune de program care trebuie executată.
4. Pe măsură ce programul dvs. devine mai complex, veți grupa declarațiile asociate în bucăți mici, ușor de gestionat, numite funcții. Grupați instrucțiunile programului folosind acolade dreapta și stânga ().
5. Majoritatea programelor C++ folosesc un flux de ieșire cout pentru a afișa informații pe ecran; cu toate acestea, utilizând operatorii de redirecționare I/O ai sistemului de operare, puteți redirecționa ieșirea cout la un fișier, un dispozitiv (cum ar fi o imprimantă) sau chiar să îl transforme în intrarea unui alt program.

Până acum, am scris programe într-un singur cod, indivizibil din punct de vedere funcțional. Algoritmul programului era conținut în funcția principală și nu existau alte funcții în program. Am scris programe mici, așa că nu a fost nevoie să ne declarăm funcțiile. Pentru scrierea de programe mari, experiența arată că este mai bine să folosiți funcții. Programul va consta din fragmente de cod separate un fragment de cod separat este o funcție. Separat, deoarece munca unei funcții separate nu depinde de munca nici unei alte. Adică, algoritmul din fiecare funcție este suficient funcțional și independent de alți algoritmi de program. Odată ce ați scris o funcție, aceasta poate fi transferată cu ușurință în alte programe. O funcție (în programare) este o bucată de cod sau un algoritm implementat într-un limbaj de programare cu scopul de a efectua o anumită secvență de operații. Deci, funcțiile vă permit să faceți un program modular, adică să împărțiți programul în mai multe subrutine mici (funcții), care îndeplinesc împreună sarcina. Un alt avantaj uriaș al funcțiilor este că pot fi reutilizate. Această caracteristică vă permite să reutilizați codul scris o dată, ceea ce, la rândul său, reduce foarte mult cantitatea de cod de program!

Pe lângă faptul că C++ prevede declararea funcțiilor sale, puteți utiliza și funcții definite în fișierele de antet standard ale limbajului de programare C++. Pentru a utiliza funcția definită în fișierul antet, trebuie să o includeți. De exemplu, pentru a utiliza o funcție care ridică un anumit număr la o putere, trebuie să includeți un fișier antet și rulați funcția pow() în corpul programului. Să dezvoltăm un program în care vom rula funcția pow().

// inc_func.cpp: Definește punctul de intrare pentru aplicația consolă. #include "stdafx.h" //acțiunea 1 - includeți fișierul antet

// cod Cod::Blocuri

// Cod Dev-C++

// inc_func.cpp: Definește punctul de intrare pentru aplicația consolă. //acțiunea 1 - includeți fișierul antet care conţine prototipuri ale funcţiilor matematice de bază #include int main(int argc, char* argv) ( float power = pow(3.14,2); //acțiunea 2 - rulează funcția de ridicare a unui număr la puterea returnată 0; )

Includerea fișierelor antet se face așa cum se arată în linia 5, adică este declarată directiva preprocesor #include, după care în interiorul caracterelor<>se scrie numele fișierului antet. Când fișierul antet este inclus, puteți utiliza funcția, care este ceea ce se face în linia 9.Funcția pow() ridică un număr 3.14 pătrat și atribuie rezultatul rezultat variabilei de putere, unde
pow — numele funcției;
numerele 3.14 și 2 sunt argumente ale funcției;

Numele funcției este întotdeauna urmat de paranteze, în interiorul cărora argumentele sunt trecute funcției, iar dacă există mai multe argumente, acestea sunt separate între ele prin virgule. Argumentele sunt necesare pentru ca funcțiile să transmită informații. De exemplu, pentru a pătra numărul 3,14 folosind funcția pow(), trebuie să spuneți cumva acestei funcție ce număr este și la ce putere să-l ridicați. Tocmai de aceea au fost inventate argumentele funcției, dar există funcții în care argumentele nu sunt transmise astfel de funcții sunt numite cu paranteze goale. Deci, pentru a utiliza o funcție din fișierul antet standard C++, trebuie să efectuați doi pași:

1. Includeți fișierul antet necesar;
2. Lansați funcția dorită.

Pe lângă apelarea funcțiilor din fișierele antet standard, limbajul de programare C++ oferă posibilitatea de a vă crea propriile funcții. Există două tipuri de funcții în limbajul de programare C++:

1. Funcții care nu returnează valori
2. Funcții care returnează o valoare

Funcțiile care nu returnează o valoare, după finalizarea activității lor, nu oferă niciun răspuns programului. Să ne uităm la structura declarării unor astfel de funcții.

// structura declarației funcțiilor care nu returnează valori void /*numele funcției*/(/*parametrii funcției*/) // antetul funcției ( // corpul funcției)

Randul 2începe cu cuvântul rezervat void este un tip de date care nu poate stoca date. Tipul de date void înseamnă că această funcție nu returnează nicio valoare. void nu are altă utilizare și este necesar doar pentru ca compilatorul să poată determina tipul funcției. După cuvântul rezervat void se scrie numele funcției. Imediat după numele funcției sunt două paranteze, una de deschidere și una de închidere. Dacă o funcție trebuie să transfere unele date, atunci parametrii funcției sunt declarați în paranteze, sunt separați unul de celălalt prin virgule. Linia 2 se numește antetul funcției. După antetul funcției, sunt scrise două acolade, în interiorul cărora există un algoritm numit corpul funcției. Să dezvoltăm un program în care declarăm o funcție pentru găsirea factorialului, iar funcția nu ar trebui să returneze o valoare.

<= numb; i++) // цикл вычисления значения n! rezult *= i; // накапливаем произведение в переменной rezult cout << numb << "! = " << rezult << endl; // печать значения n! } int main(int argc, char* argv) { int digit; // переменная для хранения значения n! cout << "Enter number: "; cin >> cifra;

// cod Cod::Blocuri

// Cod Dev-C++

faktorial(cifra);//porniți funcția de găsire a sistemului factorial(„pauză”);<= numb; i++) // цикл вычисления значения n! rezult *= i; // накапливаем произведение в переменной rezult cout << numb << "! = " << rezult << endl; // печать значения n! } int main(int argc, char* argv) { int digit; // переменная для хранения значения n! cout << "Enter number: "; cin >întoarce 0; )

folosind namespace std; // declararea unei funcții pentru găsirea n! void faktorial(int numb) // antetul funcției ( int rezult = 1; // inițializați variabila rezult cu valoarea 1 pentru (int i = 1; i > cifra; faktorial(cifra);//rularea funcției de găsire a randamentului factorial 0; ) După ce au fost incluse toate fișierele de antet necesare, puteți declara o funcție pentru găsirea factorialului Prin declararea unei funcții înțelegem alegerea numelui funcției, definirea parametrilor funcției și scrierea algoritmului care este corpul funcției. . După parcurgerea acestor pași, funcția poate fi utilizată în program. Deoarece funcția nu ar trebui să returneze o valoare, tipul returnat trebuie să fie void . Numele functiei este faktorial, in paranteze este declarata variabila numb de tip int. Această variabilă este un parametru al funcției faktorial(). Astfel, toate reclamele în linia 8 împreună alcătuiesc antetul funcției. Liniile 9 - 14 alcătuiesc corpul funcției faktorial(). În interiorul corpului, linia 10 declară variabila rezult , care va stoca rezultatul găsirii n! După care, în rândurile 11-12 Un operator de buclă for a fost declarat pentru a găsi factorialul. ÎN linia 13

Se declară operatorul cout, cu ajutorul căruia se va imprima pe ecran valoarea factorialului. Acum că funcția este declarată, o puteți utiliza. ÎN

linia 21

Este lansată funcția faktorial(digit), argumentul este trecut în parantezele funcției, adică valoarea conținută în variabila cifre. Rezultatul programului (vezi Figura 1).

Figura 1 - Funcții în C++

Structura declarațiilor de funcții rămâne aproape neschimbată, cu excepția a două linii. În antetul funcției, trebuie mai întâi să definiți tipul de date returnate, acesta poate fi un tip de date int dacă doriți să returnați un număr întreg sau un tip de date flotant pentru numerele în virgulă mobilă. În general, orice alt tip de date, totul depinde de ce ar trebui să returneze funcția. Deoarece funcția trebuie să returneze o valoare, trebuie prevăzut un mecanism special pentru aceasta, ca în linia 5. Folosind cuvântul rezervat return, puteți returna o valoare când funcția se finalizează. Tot ce este necesar este să specificați o variabilă care conține valoarea dorită, sau o anumită valoare, după instrucțiunea return. Valoare returnată tipul de date în linia 5 trebuie să se potrivească cu tipul de date în randul 2. Să reluăm programul pentru găsirea factorialului, astfel încât funcția faktorial() să returneze valoarea factorială.

// struct_func.cpp: Definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include <= numb; i++) // цикл вычисления значения n! rezult *= i; // накапливаем произведение в переменной rezult return rezult; // передаём значение факториала в главную функцию } int main(int argc, char* argv) { int digit; // переменная для хранения значения n! cout << "Enter number: "; cin >> cifra;<< digit << "! = " << faktorial(digit) << endl;// запуск функции нахождения факториала system("pause"); return 0; }

// cod Cod::Blocuri

// Cod Dev-C++

cout // struct_func.cpp: Definește punctul de intrare pentru aplicația consolă. #include<= numb; i++) // цикл вычисления значения n! rezult *= i; // накапливаем произведение в переменной rezult return rezult; // передаём значение факториала в главную функцию } int main(int argc, char* argv) { int digit; // переменная для хранения значения n! cout << "Enter number: "; cin >> cifra;<< digit << "! = " << faktorial(digit) << endl;// запуск функции нахождения факториала return 0; }

folosind namespace std; // declararea unei funcții pentru găsirea n! int faktorial(int numb) // antetul funcției ( int rezult = 1; // inițializați variabila rezult cu valoarea 1 pentru (int i = 1; i împreună alcătuiesc antetul funcției. Liniile 9 - 14 alcătuiesc corpul funcției faktorial(). În interiorul corpului, linia 10 declară variabila rezult , care va stoca rezultatul găsirii n! După care, în Funcția faktorial() are acum un tip de date returnate de int deoarece n! este un număr întreg.B Un operator de buclă for a fost declarat pentru a găsi factorialul. ÎN se declară o instrucțiune return care returnează valoarea conținută în variabila rezult. ÎN Rulem funcția faktorial(), a cărei valoare returnată este trimisă fluxului de ieșire folosind operatorul cout. S-ar putea scrie astfel: int fakt = faktorial(cifra); - variabila de tip int

atribuim valoarea returnata functiei faktorial(), dupa care variabila fakt va stoca valoarea n! . Rezultatul programului nu s-a schimbat (vezi Figura 2).

Introduceți numărul: 5 5! = 120 Pentru a continua, apăsați orice tastă. . .

Figura 2 - Funcții în C++

Am analizat două tipuri de funcții, iar declararea funcțiilor a fost efectuată în zona programului, după includerea fișierelor de antet, dar înainte de începerea funcției main(). Există mai multe moduri de a declara funcții (vezi Figura 3).

Figura 3 - Funcții în C++ Pe arată 4 moduri de a declara funcții în limbajul de programare C++. Să ne uităm la structura declarațiilor de funcții într-un singur fișier, cu funcția principală. Funcțiile pot fi declarate în două zone, înaintea funcției main() și după funcția main(). Până acum am declarat funcții într-un singur fișier, înaintea funcției main() - acesta este cel mai simplu mod.

// struct_func.cpp: Definește punctul de intrare pentru aplicația consolă. #include "stdafx.h" /*area 1 - declararea funcțiilor înainte de începerea lui main(), un loc pentru declararea funcțiilor declarate în această zonă nu au nevoie de prototipuri */ int main(int argc, char* argv) ( returnează 0; )

Dacă funcțiile sunt declarate în regiunea 1, înainte de funcția principală, atunci nu sunt necesare prototipuri pentru aceste funcții. Este un stil de programare bun pentru a declara funcții după main() . Să ne uităm la structura unei astfel de declarații de funcție.

// struct_func.cpp: Definește punctul de intrare pentru aplicația consolă. #include "stdafx.h" // loc pentru declararea prototipurilor de funcții int main(int argc, char* argv) ( return 0; ) /*area 2 - declararea funcțiilor după main() loc pentru declararea funcțiilor */

// cod Cod::Blocuri

// Cod Dev-C++

// struct_func.cpp: Definește punctul de intrare pentru aplicația consolă. // loc pentru declararea prototipurilor de funcții int main(int argc, char* argv) ( return 0; ) /*zona 2 - declararea funcțiilor după main() loc pentru declararea funcțiilor */

Zona de declarare a funcției s-a mutat la sfârșitul programului, după main() . În ceea ce privește metoda de declarare a funcțiilor în sine, aceasta nu s-a schimbat. Dar din moment ce funcțiile sunt declarate după main() , nu va fi posibilă utilizarea lor, deoarece ordinea declarațiilor s-a schimbat și funcția main() pur și simplu nu va vedea funcțiile declarate după. Deci, pentru ca aceste funcții să fie vizibile în main(), există conceptul de prototip. Un prototip de funcție este un antet de funcție care este declarat înaintea funcției main(). Și dacă declarați un prototip de funcție, atunci funcția poate fi văzută în main() .

// sintaxa declarației prototipului /*funcție returnează tipul de date*/ /*numele funcției*/(/*parametrii funcției*/);

Structura unei declarații prototip este foarte asemănătoare cu structura unei declarații de funcție. Să dezvoltăm un program care determină dacă numărul de cinci cifre introdus este un palindrom. Un palindrom este un număr sau un text care citește la fel atât în ​​stânga, cât și în dreapta: 93939; 49094; 11311.

// palindrom_func.cpp: Definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include << "Enter 5zn-e chislo: "; // введите пятизначное число int in_number, out_number; // переменные для хранения введённого пятизначного числа cin >> << "Number " << out_number << " - palendrom" << endl; else cout<<"This is not palendrom"<

// cod Cod::Blocuri

// Cod Dev-C++

// palindrom_func.cpp: Definește punctul de intrare pentru aplicația consolă. #include folosind namespace std; bool palindrom5(int); // prototipul funcției pentru găsirea unui palindrom de numere din cinci cifre int main(int argc, char* argv) ( cout<< "Enter 5zn-e chislo: "; // введите пятизначное число int in_number, out_number; // переменные для хранения введённого пятизначного числа cin >>in_numar;<< "Number " << out_number << " - palendrom" << endl; else cout<<"This is not palendrom"<

out_number = in_number; // stochează numărul introdus în variabila out_number if (palindrom5(in_number)) // dacă funcția returnează adevărat, atunci condiția este adevărată, în caz contrar funcția va returna false - false cout ÎN linia 7 a fost anunțată o funcție prototip pentru găsirea unui palindrom de numere din cinci cifre. Vă rugăm să rețineți că prototipul trebuie să se potrivească complet cu antetul funcției, dar există încă unele diferențe. De exemplu, prototipul nu trebuie să listeze numele parametrilor, este suficient să le declare tipurile de date. Ar trebui să puneți întotdeauna un punct și virgulă la sfârșitul unei declarații de prototip. În caz contrar, declarația prototipului este aceeași cu declarația antetului unei singure funcții. Prototipul trebuie declarat pentru fiecare funcție separat. Variabila out_number este folosită pentru a stoca temporar numărul introdus. ÎN linia 16 condiția instrucțiunii de selecție if rulează funcția palindrom5(). Argumentul pentru aceasta este variabila in_number. funcția va returna o valoare de tip bool, iar dacă funcția returnează true, atunci condiția va fi adevărată, în caz contrar va fi falsă. Ar fi posibil să atribuiți mai întâi valoarea returnată de funcție unei variabile și apoi să înlocuiți această variabilă în condiția instrucțiunii de selecție if, dar acest lucru ar crește codul programului cu o linie. ÎN liniile 23 - 40 Este declarată funcția palindrom5(), cu un parametru prin care un număr de cinci cifre este transmis funcției. Variabilele sold1, sold2, sold4, sold5 sunt declarate în linia 25 , și sunt necesare pentru stocarea cifrelor unui număr de cinci cifre: primul, al doilea, al patrulea, al cincilea (numerotare - de la dreapta la stânga). În rândurile 26, 29, 32, 35 se efectuează aceeași operațiune - restul diviziunii. Operația de împărțire a restului taie un bit de la dreapta la stânga și le stochează în variabilele sold1, balance2, balance4, balance5, respectiv. Mai mult, operațiunea restului de divizare alternează cu operațiunea de divizare obișnuită. Operația de împărțire se efectuează în, 30 , 33 rândurile 27 , și micșorează numărul de cinci cifre introdus în pași cu o cifră. ÎN linia 30 Operația de împărțire reduce numărul introdus cu două cifre deodată, deoarece numărul este de cinci cifre, iar cifra din mijloc nu ne interesează, poate fi orice. ÎN se declară un operator de selecție if , care compară cifrele unui număr de cinci cifre, iar dacă acestea sunt egale în mod corespunzător, atunci funcția va returna true , în caz contrar false . Rezultatul programului (vezi Figura 4).

Introduceți numărul 5zn-e: 12321 Numărul 12321 - palendrom Pentru a continua, apăsați orice tastă. . .

Figura 4 - Funcții în C++

Până acum, am declarat funcții în același fișier ca și programul principal, adică unde se află funcția main(). În C++, este posibil să plasați declarații de funcție într-un fișier separat, apoi va trebui să includeți fișierul cu funcțiile, așa cum este cazul includerii fișierelor de antet standard. Există două moduri:

1. crearea unui fișier *.cpp în care sunt declarate funcții;
2. crearea de fișiere *.cpp și *.h.

A doua metodă este un stil de programare bun. Astfel, dacă declarați funcții într-un alt fișier, atunci faceți-o conform metodei a doua. Să reluăm programul de găsire a palindromului, astfel încât declarația funcției palindrom5() să fie într-un fișier *.cpp separat. Fișierul *.h este necesar pentru a ascunde implementarea funcțiilor, adică fișierul *.h va conține prototipuri de funcție. Folosind MVS Solution Explorer, creați un fișier *.h și numiți-l palendrom.

// cod de fișier palendrom.h #ifndef palendrom #define palendrom bool palindrom5(int); // prototip al funcției de găsire a unui palindrom de numere din cinci cifre #endif

Directive în liniile 2,3,5 trebuie să fie întotdeauna declarate în fișierele prototip de funcție, iar prototipurile de funcție sunt întotdeauna declarate în fișiere *.h. După directivele scrise în liniile 2,3, dar prototipurile de funcții sunt declarate înainte de directiva #endif. Linia 4 declară prototipul funcției palindrom5(). Declarația acestei funcții se află în fișierul palendrom.cpp, care a fost creat anterior folosind MVS Solution Explorer.

// conținutul fișierului palendrom.cpp #include "stdafx.h" #include "palendrom.h" bool palindrom5(int number) // funcție pentru găsirea palindromului numerelor din cinci cifre ( int balance1, balance2, balance4, balance5 ; // variabile care stochează rezultate intermediare sold1 = număr % 10 // variabilei sold1 este alocat primul număr = număr / 10 // scade numărul introdus cu o cifră = numărul % 10; al doilea număr rămas = număr / 100 număr cu două cifre sold4 = număr % 10 // al patrulea număr rămas = număr / 10 = număr % 10; variabilei sold5 i se atribuie al cincilea rest dacă ((balance1 == balance5) && (balance2 == balance4)) returnează adevărată // funcția returnează valoarea adevărată // funcția returnează o valoare falsă;

// cod Cod::Blocuri

// Cod Dev-C++

// conținutul fișierului palendrom.cpp #include "palendrom.h" bool palindrom5(int number) // funcție pentru găsirea palindromului numerelor din cinci cifre ( int balance1, balance2, balance4, balance5; // variabile care stochează rezultate intermediare sold1 = număr % 10 // soldul variabil1 i s-a atribuit primul număr rămas = număr / 10 // scade numărul introdus cu o cifră sold2 = numărul % 10 // soldul variabil2 i s-a atribuit al doilea număr / 100; ; // scade numărul introdus cu două cifre sold4 = număr % 10 // soldul variabil4 este alocat al patrulea număr rămas / 10 // scade numărul introdus cu o cifră = număr % 10; este alocat al cincilea rest if ((balance1 == sold5) && (balance2 == balance4)) returnează adevărat // funcția returnează valoarea adevărată // funcția returnează valoarea falsă;

Fișierul palendrom.cpp conține o declarație a funcției palindrom5(). Deoarece fișierul palendrom.cpp este un fișier executabil (*.cpp sunt fișiere executabile), este necesar să includeți containerul „stdafx.h” în el, ca în randul 2. Pentru a lega fișierul în care este declarată funcția palindrom5() și fișierul cu prototipul său, să includem fișierul antet (fișierul cu prototipul), acest lucru se face în linia 3. Vă rugăm să rețineți că atunci când conectați fișierul creat de noi, sunt folosite ghilimele duble și nu mai mari sau mai mici decât semne. Tot ce rămâne este să rulați funcția palindrom5() în fișierul executabil principal func_palendrom.cpp .

// func_palendrom.cpp: Definește punctul de intrare pentru aplicația consolă. #include „stdafx.h” #include << "Enter 5zn-e chislo: "; // введите пятизначное число int in_number, out_number; // переменные для хранения введённого пятизначного числа cin >>in_numar;<< "Number " << out_number << " - palendrom" << endl; else cout<<"This is not palendrom"<

// cod Cod::Blocuri

// Cod Dev-C++

// func_palendrom.cpp: Definește punctul de intrare pentru aplicația consolă. #include // include fișierul antet, cu funcția prototip palindrom5() #include "palendrom.h" folosind namespace std; int main(int argc, char* argv) ( cout<< "Enter 5zn-e chislo: "; // введите пятизначное число int in_number, out_number; // переменные для хранения введённого пятизначного числа cin >>in_numar;<< "Number " << out_number << " - palendrom" << endl; else cout<<"This is not palendrom"<

out_number = in_number; // stochează numărul introdus în variabila out_number if (palindrom5(in_number)) // dacă funcția returnează adevărat, atunci condiția este adevărată, în caz contrar funcția va returna false - false cout linia 6 am inclus un fișier cu un prototip al funcției palindrom5(), după care putem folosi această funcție. Deci, am împărțit programul în trei fișiere:

• fișier proiect: func_palendrom.cpp
• fișier antet palendrom.h
• fișier executabil palendrom.cpp

Asociem fișierul proiect cu fișierul antet și asociem fișierul antet cu fișierul executabil, caz în care fișierul proiect va vedea funcția palindrom5() și o va putea rula.

Etichete: Funcții în C, prototip, descriere, definiție, apel. Parametri formali și parametrii actuali. Argumente ale funcției, trecere prin valoare, trecere prin pointer. Valoare returnată.

Introducere

Cu cât studiem mai mult C, cu atât programele devin mai mari. Colectăm toate acțiunile într-o singură funcție principală și copiem aceleași acțiuni de mai multe ori, creând zeci de variabile cu nume unice. Programele noastre se umflă și devin din ce în ce mai puțin înțelese, ramurile devin mai lungi și mai ramificate.

Dar există o cale de ieșire din această situație! Acum vom învăța cum să creăm funcții în C. Funcțiile, în primul rând, vor ajuta la separarea codului duplicat în subprograme separate, în al doilea rând, vor ajuta la împărțirea logic a programului în părți și, în al treilea rând, funcțiile din C au multe caracteristici asociate cu ele care vor permite utilizarea de noi abordări pentru structurarea aplicațiilor.

O funcție este o parte numită a unui program care poate fi apelată în mod repetat dintr-o altă parte a programului (în care funcția este vizibilă). O funcție poate lua un număr fix sau variabil de argumente sau nu poate avea niciun argument. O funcție poate returna o valoare sau poate fi goală (void) și nu returnează nimic.

Suntem deja familiarizați cu multe funcții și știm cum să le numim - acestea sunt funcții ale bibliotecilor stdio, stdlib, string, conio etc. Mai mult, main este și o funcție. Se deosebește de celelalte doar prin faptul că este punctul de intrare la lansarea aplicației.
O funcție în C este definită într-un context global. Sintaxa funcției: (, ...) ( )

Cel mai simplu exemplu este o funcție care ia un număr flotant și returnează pătratul acestui număr

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include float sqr(float x) ( float tmp = x*x; return tmp; ) void main() ( printf("%.3f", sqr(9.3f)); getch(); )

În interiorul funcției sqr, am creat o variabilă locală căreia i-a fost atribuită valoarea argumentului. Numărul 9.3 a fost transmis ca argument funcției. Cuvântul service return returnează valoarea variabilei tmp. Puteți rescrie funcția după cum urmează:

Float sqr(float x) ( returnează x*x; )

În acest caz, înmulțirea va fi efectuată mai întâi, iar apoi valoarea va fi returnată. Dacă funcția nu returnează nimic, tipul de returnare va fi nul. De exemplu, o funcție care imprimă pătratul unui număr:

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

în acest caz, return înseamnă părăsirea funcției. Dacă funcția nu returnează nimic, atunci returnarea nu trebuie să fie scrisă. Apoi funcția își va finaliza finalizarea și controlul va reveni la funcția de apelare.

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

Dacă funcția nu primește argumente, parantezele rămân goale. De asemenea, puteți scrie cuvântul gol:

Void printHelloWorld() ( printf("Buna ziua Lumea"); )

echivalent

Void printHelloWorld(void) ( printf(„Buna ziua Lumea”); )

Parametri formali și actuali

Când se declară o funcție, sunt specificați parametrii formali, care sunt apoi utilizați în cadrul funcției în sine. Când apelăm o funcție, folosim parametrii actuali. Parametrii actuali pot fi variabile de orice tip adecvat sau constante.

De exemplu, să presupunem că există o funcție care returnează pătratul unui număr și o funcție care însumează două numere.

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include //Parametrii formali au denumiri a și b //folosindu-le accesăm argumentele transmise în interiorul funcției int sum(int a, int b) ( return a+b; ) float square(float x) ( return x*x; ) void main() ( //Parametrii actuali pot avea orice nume, inclusiv niciun nume int unu = 1; float doi = 2.0; //Trece variabile, a doua variabilă este turnată la tipul dorit printf("%d\n" , sum(one, two)); //Trece constantele numerice printf("%d\n", sum(10, 20)); ("%d\n ", sum(10, 20.f) //O variabilă de tip întreg este convertită într-un tip de virgulă mobilă printf("%.3f\n", pătrat(un)); Un apel de funcție poate fi folosit și ca argument, care returnează valoarea dorită printf("%.3f\n", square(sum(2 + 4, 3)));

Vă rugăm să rețineți că turnarea tipului are loc implicit și numai atunci când este posibil. Dacă o funcție primește un număr ca argument, atunci nu i se poate transmite un șir variabil, de exemplu „20”, etc. În general, este mai bine să folosiți întotdeauna tipul corect sau să turnați în mod explicit tipul la cel dorit.
Dacă o funcție returnează o valoare, aceasta nu trebuie să fie stocată. De exemplu, folosim funcția getch, care citește un caracter și îl returnează.

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include void main() ( char c; do ( //Salvează valoarea returnată într-o variabilă c = getch(); printf("%c", c); ) while(c != "q"); //Returul valoarea nu este salvată getch();

Argumente de trecere

La transmiterea argumentelor, acestea sunt copiate. Aceasta înseamnă că orice modificări pe care o funcție le face variabilelor au loc numai în cadrul funcției. De exemplu

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include void schimbare(int a) ( a = 100; printf("%d\n", a); ) void main() (int d = 200; printf("%d\n", d); schimbare(d) ; printf("%d", d);

Se vor afișa programele
200
100
200
Este clar de ce. În interiorul funcției lucrăm cu variabila x, care este o copie a variabilei d. Schimbăm copia locală, dar variabila d în sine nu se schimbă. După ieșirea funcției, variabila locală va fi distrusă. Variabila d nu se va modifica în niciun fel.
Atunci cum poți schimba variabila? Pentru a face acest lucru, trebuie să transmiteți adresa acestei variabile. Să rescriem funcția astfel încât să accepte un pointer de tip int

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include void schimbare(int *a) ( *a = 100; printf("%d\n", *a); ) void main() (int d = 200; printf("%d\n", d); modificare (&d); printf("%d", d);

Acum iese programul
200
100
100
Aici a fost creată și o variabilă locală, dar din moment ce adresa a fost transmisă, am schimbat valoarea variabilei d folosind adresa acesteia din RAM.

În programare, prima metodă de transmitere a parametrilor se numește trecere după valoare, a doua - trecere prin indicator. Amintiți-vă o regulă simplă: dacă doriți să schimbați o variabilă, trebuie să treceți un pointer către acea variabilă funcției. Prin urmare, pentru a schimba un pointer, trebuie să treceți un pointer către un pointer etc. De exemplu, să scriem o funcție care va lua dimensiunea unei matrice int și o va crea. La prima vedere, funcția ar trebui să arate cam așa:

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include #include void init(int *a, unsigned size) ( a = (int*) malloc(size * sizeof(int)); ) void main() ( int *a = NULL; init(a, 100); if (a = = NULL) ( printf("EROARE"); ) else ( printf("OK..."); liber(a); ) getch();

Dar această funcție va afișa EROARE. Am transmis adresa variabilei. În cadrul funcției init, a fost creată o variabilă locală a care stochează adresa matricei. După ce funcția a ieșit, această variabilă locală a fost distrusă. Pe lângă faptul că nu am putut obține rezultatul dorit, am descoperit o scurgere de memorie: memoria a fost alocată pe heap, dar nu mai există o variabilă care să stocheze adresa acestei zone.

Pentru a schimba un obiect, trebuie să treceți un pointer către acesta, în acest caz un pointer către un pointer.

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include #include void init(int **a, unsigned size) ( *a = (int*) malloc(size * sizeof(int)); ) void main() ( int *a = NULL; init(&a, 100); if ( a == NULL) ( printf("EROARE"); ) else ( printf("OK..."); liber(a); ) getch();

Acum totul funcționează așa cum ar trebui.
Un alt exemplu similar. Să scriem o funcție care ia un șir ca argument și returnează un pointer către zona de memorie în care a fost copiat acest șir.

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include #include #include char* initByString(const char *str) ( char *p = (char*) malloc(strlen(str) + 1); strcpy(p, str); return p; ) void main() ( char *test = initByString( "Bună lume!"); printf("%s", test);

Nu există nicio scurgere de memorie în acest exemplu. Am alocat memorie folosind funcția malloc, am copiat un șir acolo și apoi am returnat un pointer. Variabilele locale au fost eliminate, dar variabila de testare stochează adresa unei bucăți de memorie pe heap, astfel încât aceasta poate fi eliminată folosind funcția liberă.

Declarația funcției și definirea funcției. Crearea propriei biblioteci

În C, puteți declara o funcție înainte de a o defini. O declarație de funcție, prototipul ei, constă dintr-o valoare returnată, numele funcției și tipul argumentelor. Numele argumentelor pot fi omise. De exemplu

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include //Prototipuri de funcții. Numele argumentelor nu trebuie scrise int odd(int); int even(int); void main() ( printf(„dacă %d impar? %d\n”, 11, impar(11)); printf(„dacă %d impar? %d\n”, 10, impar(10)); getch (); ) //Definiția funcțiilor int even(int a) ( if (a) ( odd(--a); ) else ( return 1; ) ) int odd(int a) ( if (a) ( even(); - -a); else ( return 0; ) )

Aceasta este o recursivitate mixtă - funcția impar returnează 1 dacă numărul este impar și 0 dacă este par.

De obicei, declarația funcției este plasată separat, în fișierul .h, iar definițiile funcției în fișierul .c. Astfel, fișierul antet reprezintă interfața bibliotecii și arată cum să lucrați cu ea fără a intra în conținutul codului.

Să creăm o bibliotecă simplă. Pentru a face acest lucru, va trebui să creați două fișiere - unul cu extensia .h și să plasați acolo prototipurile de funcție, iar celălalt cu extensia .c și să plasați acolo definițiile acestor funcții. Dacă lucrați cu un IDE, atunci fișierul .h trebuie creat în folderul Fișiere antet, iar fișierele de cod în folderul Fișiere cod sursă. Fișierele să fie numite File1.h și File1.c
Să rescriem codul anterior. Așa va arăta fișierul antet File1.h

#ifndef _FILE1_H_ #define _FILE1_H_ int odd(int); int even(int); #endif

Conținutul fișierului cod sursă File1.c

#include "Fișier1.h" int even(int a) ( dacă (a) ( impar (--a); ) else ( returnează 1; ) ) int impar (int a) ( dacă (a) ( par (--) a); else ( returnează 0; ) )

Funcția noastră principală

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include #include „File1.h” void main() ( printf(„dacă %d impar? %d\n”, 11, impar(11)); printf(„dacă %d impar? %d\n”, 10, impar (10));

Să ne uităm la caracteristicile fiecărui fișier. Fișierul nostru, care conține funcția principală, include bibliotecile de care are nevoie, precum și fișierul antet File1.h. Compilatorul cunoaște acum prototipurile funcției, adică știe tipul de returnare, numărul și tipul de argumente și numele funcțiilor.

Fișierul antet, așa cum sa menționat mai devreme, conține prototipul funcției. Bibliotecile folosite pot fi incluse și aici. Protecție macro #define _FILE1_H_ etc. folosit pentru a preveni copierea din nou a codului bibliotecii în timpul compilării. Aceste linii pot fi înlocuite cu una

#pragma once int odd(int); int even(int);

Fișierul de cod sursă File1.c include fișierul său antet. Totul este logic și simplu, ca de obicei. În fișierele antet, pe lângă prototipurile de funcții, este obișnuit să se includă constante, substituții de macro și să se definească noi tipuri de date. În plus, în fișierele antet puteți comenta pe larg codul și puteți scrie exemple de utilizare a acestuia.

Transmiterea unui tablou ca argument

După cum am menționat mai devreme, numele matricei este înlocuit cu un pointer, astfel încât trecerea unei matrice unidimensionale este echivalentă cu trecerea unui pointer. Exemplu: funcția primește o matrice și dimensiunea acesteia și tipărește:

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include void printArray(int *arr, unsigned size) ( unsigned i; for (i = 0; i< size; i++) { printf("%d ", arr[i]); } } void main() { int x = {1, 2, 3, 4, 5}; printArray(x, 10); getch(); }

În acest exemplu, funcția ar putea arăta astfel

Void printArray(int arr, unsigned size) ( unsigned i; for (i = 0; i)< size; i++) { printf("%d ", arr[i]); } }

Permiteți-mi să vă reamintesc, de asemenea, că regula pentru înlocuirea unui tablou cu un pointer nu este recursivă. Aceasta înseamnă că este necesar să se specifice dimensiunea matricei bidimensionale la transmitere

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include void printArray(int arr, unsigned size) ( unsigned 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(); }

Sau poți scrie

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include void printArray(int (*arr), unsigned size) ( unsigned 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(); }

Dacă o matrice bidimensională este creată dinamic, atunci puteți trece un pointer către un pointer. De exemplu, o funcție care preia o matrice de cuvinte și returnează o matrice de numere întregi egale cu lungimea fiecărui cuvânt:

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include #include #include #define SIZE 10 unsigned* getLengths(const char **words, unsigned size) ( 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(); }

În loc să returnați un pointer către o matrice, puteți trece o matrice care trebuie completată

Primul dialect standard al lui C (C89), deși permitea deja intrări cu cuvântul cheie void, permitea totuși această utilizare a implicit int pentru a menține compatibilitatea cu codul existent. Dialectul modern al lui C (C99) nu permite absența specificatorilor de tip în numele și declarațiile de tip. #include #include #include #define SIZE 10 void getLengths(const char **cuvinte, unsigned size, 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(); }

Aici se încheie prima cunoaștere a funcțiilor: subiectul este foarte amplu și este împărțit în mai multe articole.