clasa a XI-a · Subprograme · lecția 1
Subprograme (1): funcții care returnează o valoare
60 minmate-info
Înainte de lecția asta: IX.9 Cifrele unui număr: sumă, oglindit, palindrom, construire de numere, IX.10 Divizibilitate: divizori, numere prime, cmmdc și cmmmc
Ce vei ști după lecție
- Înțelegi de ce împărțim un program în subprograme (modularizare, reutilizare).
- Definești o funcție: tip returnat, nume, parametri, corp, return.
- Apelezi funcții din main și din alte funcții.
- Deosebești parametrii formali de cei efectivi și variabilele locale de cele globale.
- Scrii definiția completă a unui subprogram exact cum se cere la Bac (III.1).
Lecția are și o fișă de lucru, de rezolvat după ce o citești. Mergi la fișă ↓
Clasa a XI-aLecția 1 din 21 · mai sunt 20Urmează: XI.2 · Subprograme (2): parametri prin referință și subprograme cu tablouriVezi toate lecțiile
Cuprins
- Ideea: o bucată de program cu nume
- Anatomia unei funcții
- Funcții bool: „este … ?”
- Funcții void: fac ceva, nu întorc nimic
- Funcții care se ajută între ele
- Unde se scrie funcția: prototipul
- Variabile locale și globale
- Cum arată cerința la Bac (III.1)
- Greșeli frecvente
- La BAC
- Exersează pe hârtie
- Mai departe (pentru cine vrea mai mult)
- Rezumat
- Fișa de lucru
- Probleme de lucru
- Temă
- Grile din subiectele de BAC
- Citește și exersează în plus
- Răspunsuri
Fișiere PDF și de lucru
- Lecția în PDF
versiunea de printat
- Fișa de lucru: Subprograme: funcții, parametri, referințe
6 pagini · 100 min
1. Ideea: o bucată de program cu nume
Imaginează-ți că trebuie să verifici dacă un număr este prim în trei locuri din același program. Fără subprograme ai copia de trei ori aceeași buclă; dacă găsești o greșeală, o repari în trei locuri. Cu un subprogram (o funcție) scrii bucla o singură dată, îi dai un nume (prim) și o apelezi de câte ori ai nevoie.
De ce așa?
De ce împărțim programul în funcții? (1) Reutilizare: scrii o dată, folosești de multe ori. (2) Claritate: if (prim(x)) se citește ca o propoziție, pe când zece rânduri de buclă trebuie descifrate. (3) Testare: poți verifica fiecare funcție separat. (4) Lucru în echipă: fiecare scrie câte o funcție, iar ceilalți o folosesc fără să-i cunoască interiorul.
2. Anatomia unei funcții
#include <iostream>
using namespace std;
int sumaCifre(int n) // antet: tip returnat, nume, lista de parametri
{ // corp
int s = 0; // variabilă locală
while (n > 0)
{
s += n % 10;
n /= 10;
}
return s; // valoarea „trimisă înapoi” celui care a apelat
}
int main()
{
int x;
cin >> x;
cout << sumaCifre(x); // apel; x este parametru EFECTIV
return 0;
}| Termen | În exemplu |
|---|---|
| tip returnat | int |
| nume | sumaCifre |
| parametru formal (în definiție) | int n |
| parametru efectiv (la apel) | x (sau 123, sau x + 1) |
| variabilă locală | s (există doar în timpul execuției funcției) |
return |
oprește funcția și întoarce valoarea |
Urmărire pentru apelul sumaCifre(2024):
| pas | n | s |
|---|---|---|
| intrare în funcție | 2024 | 0 |
| după prima iterație | 202 | 4 |
| după a doua | 20 | 6 |
| după a treia | 2 | 6 |
| după a patra | 0 | 8 |
return s |
(dispare) | 8 |
Intrare / ieșire
| Intrare | Ieșire |
|---|---|
2024 |
8 |
0 |
0 |
De ce așa?
De ce tipul funcției (int) apare înaintea numelui? Compilatorul trebuie să știe ce fel de valoare se obține la apel, ca să o poată folosi într-o expresie: sumaCifre(123) + sumaCifre(45) este o sumă de două numere întregi, deci valoarea funcției are tip int.
Parametrii prin valoare sunt copii
La apel, valoarea parametrului efectiv se copiază în parametrul formal. Funcția poate modifica copia, dar variabila originală rămâne neschimbată. (Cum modificăm originalul: lecția următoare.)
3. Funcții bool: „este … ?”
#include <iostream>
using namespace std;
bool prim(int n)
{
if (n < 2) return false;
for (int d = 2; d * d <= n; d++)
if (n % d == 0) return false; // am găsit un divizor: ieșim imediat
return true; // nu am găsit niciunul
}
int main()
{
int n, x, cnt = 0;
cin >> n;
for (int i = 1; i <= n; i++)
{
cin >> x;
if (prim(x)) cnt++;
}
cout << cnt;
return 0;
}De ce așa?
De ce return false în interiorul buclei? return termină toată funcția. Când găsim un singur divizor, răspunsul este deja „nu e prim”; nu mai are sens să continuăm. De ce return true abia după buclă? Putem afirma „e prim” doar după ce am verificat toți candidații.
Urmărire pentru prim(15) și prim(13):
| apel | d | d·d ≤ n? | n % d | decizie |
|---|---|---|---|---|
prim(15) |
2 | 4 ≤ 15 da | 1 | continuă |
| 3 | 9 ≤ 15 da | 0 | return false |
|
prim(13) |
2 | 4 ≤ 13 da | 1 | continuă |
| 3 | 9 ≤ 13 da | 1 | continuă | |
| 4 | 16 ≤ 13 nu | — | return true |
Intrare / ieșire
| Intrare | Ieșire |
|---|---|
52 9 7 1 13 |
3 (2, 7 și 13 sunt prime) |
31 4 6 |
0 |
Sfat
O funcție bool are de obicei un nume care sună ca o întrebare (prim, palindrom, existaCifra), iar apelul se citește natural în if.
4. Funcții void: fac ceva, nu întorc nimic
#include <iostream>
using namespace std;
void afiseazaDivizori(int n)
{
for (int d = 1; d <= n; d++)
if (n % d == 0) cout << d << ' ';
}
int main()
{
int x;
cin >> x;
afiseazaDivizori(x); // apel de sine stătător, nu într-o expresie
return 0;
}Funcția void nu are return valoare; (poate avea doar return; ca să iasă mai devreme) și se apelează ca instrucțiune.
5. Funcții care se ajută între ele
Funcțiile se pot apela una pe alta. Să verificăm dacă un număr este palindrom, întâi mutând „oglindirea” într-o funcție:
#include <iostream>
using namespace std;
int oglindit(int n)
{
int o = 0;
while (n > 0)
{
o = o * 10 + n % 10;
n /= 10;
}
return o;
}
bool palindrom(int n)
{
return n == oglindit(n); // o funcție o apelează pe alta
}
int main()
{
int x;
cin >> x;
cout << (palindrom(x) ? "DA" : "NU");
return 0;
}De ce așa?
De ce return n == oglindit(n);? Expresia n == oglindit(n) are valoare adevărat/fals, exact ce întoarce o funcție bool. Nu mai e nevoie de if (...) return true; else return false;. De ce 10 nu e palindrom? oglindit(10) = 1 (cifra 0 de la sfârșit dispare la oglindire), iar 10 ≠ 1.
6. Unde se scrie funcția: prototipul
Funcția trebuie să fie cunoscută înainte de locul în care e apelată. Ai două variante: o scrii deasupra lui main, sau scrii sus doar prototipul (antetul urmat de ;) și definiția mai jos.
int sumaCifre(int n); // prototip: promite că funcția există
int main() { cout << sumaCifre(2024); }
int sumaCifre(int n) { /* ... */ return 0; }7. Variabile locale și globale
| Globală | Locală | |
|---|---|---|
| unde se declară | în afara oricărei funcții | într-o funcție sau bloc |
| unde se vede | peste tot, după declarare | doar în funcția/blocul ei |
| valoare inițială | 0 | necunoscută („gunoi”) |
| durata | cât rulează programul | doar cât se execută funcția |
Dacă o variabilă locală are același nume cu una globală, în funcție se folosește cea locală (o „ascunde” pe cea globală).
Atenție — greșeli frecvente
Nu folosi variabile globale ca scurtătură pentru a transmite date funcțiilor. La Bac se cere ca subprogramul să lucreze cu parametrii din antetul dat, iar o funcție care depinde de variabile globale e greu de testat și de reutilizat.
8. Cum arată cerința la Bac (III.1)
„Subprogramul
nrDivare un singur parametru,n, prin care primește un număr natural (n ∈ [1, 10⁹]). Subprogramul returnează numărul divizorilor luin. Scrieți definiția completă a subprogramului.”
#include <iostream>
using namespace std;
int nrDiv(int n)
{
int cnt = 0;
for (int d = 1; d * d <= n; d++)
if (n % d == 0)
{
cnt++; // divizorul d
if (d != n / d) cnt++; // și perechea lui, n / d, dacă e diferită
}
return cnt;
}
int main() // la Bac NU scrii main; aici îl avem doar ca să testăm
{
int x;
cin >> x;
cout << nrDiv(x);
return 0;
}De ce așa?
De ce se oprește bucla la d * d <= n? Divizorii vin în perechi (d, n/d); unul dintre ei este ≤ √n. Parcurgând doar până la √n (≈ 31 623 pași pentru n = 10⁹ față de 10⁹) găsim toate perechile. De ce if (d != n / d)? Pentru pătrate perfecte (de ex. 36 = 6·6) perechea lui 6 este tot 6; fără verificare l-am număra de două ori.
La BAC
La Bac se cere doar definiția subprogramului: nu scrie main, nu citi n de la tastatură în subprogram (îl primești ca parametru) și nu afișa rezultatul (îl returnezi). Respectă exact numele și ordinea parametrilor din enunț.
9. Greșeli frecvente
| Greșeala | Efect | Corect |
|---|---|---|
uiți return într-o funcție non-void |
valoare întoarsă necunoscută | toate căile ajung la return |
return în buclă când vrei doar să ieși din buclă |
funcția se termină prea devreme | break pentru buclă |
citești n cu cin în subprogram |
strici formatul cerut la Bac | folosește parametrul |
funcția prim cu d <= n |
n % n == 0, deci niciun număr nu e prim |
d * d <= n |
| apelezi funcția înainte de definiție, fără prototip | eroare de compilare | prototip sau definiție deasupra |
modifici n și speri că se modifică în main |
nu se modifică (copie) | referință (lecția următoare) |
10. La BAC
La BAC
Subiectul III.1 cere definirea unui subprogram simplu (cifre, divizori, cmmdc, o proprietate a numerelor). Pașii: (1) citește antetul din enunț; (2) alege tipul returnat (int, bool, void); (3) calculează în variabile locale; (4) return. La Subiectul I apar grile despre antet corect, valoarea unui apel și despre variabile locale/globale.
11. Exersează pe hârtie
Răspunsurile sunt la final: încearcă întâi singur.
1. Ce afișează?
int f(int x) { x = x * 2; return x + 1; }
int main() { int a = 5; cout << f(a) << ' ' << a; }2. Ce afișează cout << mx(mx(3, 8), 5);, dacă int mx(int a, int b) { return a > b ? a : b; }?
3. Care este antetul corect al unei funcții cifre care primește un număr natural n și returnează numărul lui de cifre?
4. Ce afișează?
int f(int x) { if (x % 2 == 0) return x / 2; return 3 * x + 1; }
cout << f(f(f(6)));5. Ce afișează?
int x = 5;
void f() { int x = 2; x++; }
int main() { f(); cout << x; }6. Funcția prim are bucla for (int d = 2; d <= n; d++) în loc de d * d <= n. Pentru ce valori ale lui n returnează true?
7. Scrie definiția funcției nrCifrePare(n), care returnează numărul cifrelor pare ale lui n (considerăm nrCifrePare(0) = 1).
8. Câți pași face prim(n) cel mult pentru n = 10⁹? Dar o variantă cu d <= n?
9. Cât este sumaCifre(123) + sumaCifre(45)?
12. Mai departe (pentru cine vrea mai mult)
Supraîncărcare (overloading). Poți avea mai multe funcții cu același nume, dacă diferă prin parametri: int aria(int l) (pătrat) și int aria(int l, int L) (dreptunghi). Compilatorul o alege pe cea potrivită.
Parametri impliciti. int putere(int a, int b = 2) poate fi apelat ca putere(5) (= 25) sau putere(5, 3).
Variabile static. O variabilă locală declarată static își păstrează valoarea între apeluri (utilă pentru a număra de câte ori a fost apelată funcția).
Fișiere antet. În proiecte mari, prototipurile se pun într-un fișier .h, iar definițiile într-un .cpp; așa se împarte un program între mai mulți oameni.
Funcții lambda. În C++ modern: auto patrat = [](int x) { return x * x; };. Le vei întâlni la sort cu comparator (vezi lecția X.12).
Rezumat
tip nume(parametri) { … return valoare; };voiddacă nu întoarce nimic.- Parametri prin valoare = copii; modificările nu se văd în afară.
- Locale: există doar în funcție, necunoscute la început. Globale: peste tot, pornesc de la 0.
boolpentru „este … ?”;returnoprește funcția imediat.- La Bac: doar definiția, cu numele și parametrii din enunț.
Fișa de lucru
Ai citit lecția? Printează fișa sau deschide-o pe ecran și rezolvă exercițiile în ordine.
Fișă de lucru · 6 pagini · 100 min
Subprograme: funcții, parametri, referințe
- Urmărești apeluri cu parametri prin valoare și prin referință, variabile locale și globale.
- Alegi antetul corect: tipul returnat, ce se primește și ce se furnizează prin `&`.
- Scrii subprograme ca la BAC (III.1): doar definiția, cu numele și parametrii din enunț.
Fișa acoperă și: XI.2
Te-ai blocat la un exercițiu?
Probleme de lucru
Începe cu acestea, în ordine. Problemele se deschid pe pbinfo.ro, unde trimiți soluția și primești punctajul.
- ușoară
primalitate#14
Pe pbinfo scrii DOAR funcția — main-ul există deja.
https://www.pbinfo.ro/probleme/14/primalitate
- ușoară
sumciff#897
https://www.pbinfo.ro/probleme/897/sumciff
- ușoară
oglindit2#24
https://www.pbinfo.ro/probleme/24/oglindit2
Temă
Rezolvă-le singur și bifează ce ai terminat. Bifele rămân salvate în acest browser.
- ușoară
https://www.pbinfo.ro/probleme/16/suma-divizorilor
- ușoară
celmaimarenr#25
https://www.pbinfo.ro/probleme/25/celmaimarenr
- ușoară
cifre-zero#27
https://www.pbinfo.ro/probleme/27/cifre-zero
- ușoară
https://www.pbinfo.ro/probleme/76/fultimacifrapara
- ușoară
factorialf#896
https://www.pbinfo.ro/probleme/896/factorialf
- ușoară
concat#904
https://www.pbinfo.ro/probleme/904/concat
- ușoară
- ușoară
- ușoară
Grile din subiectele de BAC
Exerciții de tip grilă din variantele de Bacalaureat. Se rezolvă pe pbinfo.ro, care îți verifică imediat răspunsul.
- #469care este antetul corect al unei funcții
https://www.pbinfo.ro/?pagina=itemi-evaluare&id=469
- #470funcția smax: valoarea unui apel
https://www.pbinfo.ro/?pagina=itemi-evaluare&id=470
- #472funcția min cu două valori întregi: valoarea unei expresii
https://www.pbinfo.ro/?pagina=itemi-evaluare&id=472
- #473subprogramul scif returnează suma cifrelor: valoarea unui apel
https://www.pbinfo.ro/?pagina=itemi-evaluare&id=473
- #617antetul corect al subprogramului cifre
https://www.pbinfo.ro/?pagina=itemi-evaluare&id=617
- #1725funcția mini(int x, int y): ce returnează un apel
https://www.pbinfo.ro/?pagina=itemi-evaluare&id=1725
Citește și exersează în plus
- Subprograme · pbinfo.ro
https://www.pbinfo.ro/articole/3656/subprograme
- Anatomia unei funcții C++ · pbinfo.ro
https://www.pbinfo.ro/articole/3662/anatomia-unei-functii-c-c
- Definirea și declararea unei funcții C++ · pbinfo.ro
https://www.pbinfo.ro/articole/3664/definirea-si-declararea-unei-functii-c-c
- Declararea variabilelor (locale, globale) · pbinfo.ro
https://www.pbinfo.ro/articole/3665/declararea-variabilelor
- cppreference — Functions · en.cppreference.com
referința oficială despre funcții (engleză)
https://en.cppreference.com/w/cpp/language/functions
- Python Tutor pentru C++ · pythontutor.com
vezi cum apar și dispar variabilele locale la fiecare apel
https://pythontutor.com/cpp.html
- LearnCpp — Introduction to functions · learncpp.com
explicații detaliate cu multe exemple (engleză)
https://www.learncpp.com/cpp-tutorial/introduction-to-functions/
Te-ai blocat la lecția asta?
Scrie-mi ce nu iese și vedem împreună de unde se blochează.
Răspunsuri
Exersează pe hârtie
1. 11 5: f(a) lucrează pe o copie (x devine 10, se returnează 11), a rămâne 5.
2. 8: mx(3, 8) = 8, apoi mx(8, 5) = 8.
3. int cifre(int n). (Returnează un număr, deci tipul este int; parametrul este un număr întreg.)
4. 5: f(6) = 3 (par: 6/2), f(3) = 10 (impar: 3·3+1), f(10) = 5 (par: 10/2).
5. 5: funcția f modifică variabila locală x (care o ascunde pe cea globală); globala rămâne 5.
6. Pentru n < 2 funcția returnează false din prima verificare. Pentru n ≥ 2 bucla ajunge la d = n, iar n % n == 0 produce return false. Deci funcția nu returnează true pentru niciun număr, nici măcar pentru cele prime. Corect: d * d <= n, ca să nu se ajungă la d = n.
7.
#include <iostream>
using namespace std;
int nrCifrePare(int n)
{
if (n == 0) return 1; // cifra 0 este pară
int cnt = 0;
while (n > 0)
{
int c = n % 10; // ultima cifră
if (c % 2 == 0) cnt++;
n /= 10;
}
return cnt;
}
int main()
{
int x;
cin >> x;
cout << nrCifrePare(x);
return 0;
}Atenție: paritatea se testează pe ultima cifră (n % 10), nu pe n. Pentru 4081 cifrele pare sunt 4, 0 și 8, deci rezultatul este 3. Cazul n = 0 se tratează separat, pentru că bucla while (n > 0) nu ar număra nimic.
8. Cu d * d <= n: cel mult √(10⁹) ≈ 31 623 pași. Cu d <= n: până la 10⁹ pași (dar oricum ar returna false la d = n).
9. 6 + 9 = 15 (1 + 2 + 3 = 6; 4 + 5 = 9).