Subprograme Definite de Utilizator în C++ 10
1. Obiectivele lecției:
- Să înțeleagă conceptul de subprograme definite de utilizator în C++.
- Să învețe să declare, să definească și să utilizeze funcții create de utilizator.
- Să implementeze exemple practice care folosesc funcții pentru a rezolva probleme comune.
2. Ce sunt subprogramele definite de utilizator?
- Definiție: Subprogramele definite de utilizator sunt funcții create de programator pentru a rezolva probleme specifice. Acestea sunt module independente care pot fi apelate de mai multe ori în program, reducând redundanța și îmbunătățind lizibilitatea codului.
- Avantaje:
- Reutilizare de cod.
- Organizare mai bună a programului.
- Debugging mai simplu.
3. Structura unei funcții în C++
- Declarație (prototip):
tip_returnare nume_functie(parametrii_opționali);
- Definiție:
tip_returnare nume_functie(parametrii_opționali) {
// Bloc de instrucțiuni
return valoare; // opțional, dacă tipul de returnare este void
}
- Apelare:
nume_functie(argumente_opționale);
4. Categorii de funcții
- Funcții fără parametri și fără returnare:
- Utilizate pentru operații simple care nu necesită intrări sau ieșiri.
Exemplu:
#include <iostream>
using namespace std;
void salut() {
cout << „Salut, lume!” << endl;
}
int main() {
salut(); // Apel funcție
return 0;
}
- Funcții cu parametri, dar fără returnare:
- Utilizate pentru operații care necesită intrări, dar nu returnează valori.
Exemplu:
#include <iostream>
using namespace std;
void afiseazaSuma(int a, int b) {
cout << „Suma este: ” << a + b << endl;
}
int main() {
afiseazaSuma(3, 5);
return 0;
}
- Funcții fără parametri, dar cu returnare:
- Returnează o valoare calculată, fără a avea nevoie de intrări.
Exemplu:
#include <iostream>
using namespace std;
int daNumarAleator() {
return 42;
}
int main() {
cout << „Numărul generat: ” << daNumarAleator() << endl;
return 0;
}
- Funcții cu parametri și cu returnare:
- Cele mai versatile funcții, care primesc intrări și returnează o valoare.
Exemplu:
#include <iostream>
using namespace std;
int inmulteste(int a, int b) {
return a * b;
}
int main() {
int rezultat = inmulteste(4, 5);
cout << „Rezultatul este: ” << rezultat << endl;
return 0;
}
5. Transmiterea parametrilor
- Prin valoare:
- Parametrii sunt copiați, iar modificările nu afectează variabilele originale.
Exemplu:
void modifica(int x) {
x = 10;
}
- Prin referință:
- Se transmite adresa variabilei, iar modificările afectează variabila originală.
Exemplu:
void modifica(int& x) {
x = 10;
}
- Prin pointer:
- Similar cu referința, dar se folosește sintaxa pointerilor.
Exemplu:
void modifica(int* x) {
*x = 10;
}
6. Funcții recursive
- Definiție: O funcție care se apelează pe ea însăși pentru a rezolva o problemă divizată în subprobleme.
- Exemplu: Factorial
#include <iostream>
using namespace std;
int factorial(int n) {
if (n == 0) {
return 1;
}
return n * factorial(n – 1);
}
int main() {
cout << „Factorial de 5: ” << factorial(5) << endl;
return 0;
}
7. Exemple practice
- Funcție pentru determinarea maximului dintre două numere:
int maxim(int a, int b) {
return (a > b) ? a : b;
}
- Funcție pentru verificarea unui număr prim:
bool estePrim(int n) {
if (n < 2) return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
- Funcție pentru calculul sumei elementelor dintr-un vector:
int sumaVector(int vec[], int dim) {
int suma = 0;
for (int i = 0; i < dim; i++) {
suma += vec[i];
}
return suma;
}
8. Activități practice pentru elevi
- Scrieți o funcție care determină dacă un număr este par sau impar.
- Realizați o funcție care calculează suma cifrelor unui număr.
- Implementați o funcție care verifică dacă un șir este palindrom.
9. Scheme logice
- Funcție simplă:
- Start -> Parametru -> Instrucțiuni -> Returnare (opțional) -> Stop.
- Funcție recursivă:
- Start -> Verificare condiție de bază -> Apel recursiv -> Returnare rezultat -> Stop.
10. Concluzie
- Subprogramele definite de utilizator sunt esențiale pentru a structura și organiza programele complexe.
- Alegerea parametrilor și a tipului de returnare depinde de cerințele problemei.
- Practica și utilizarea subprogramelor ajută la dezvoltarea unor soluții modulare și eficiente.