Invatare Atomica

Vreau sa creez propriile mele comenzi in C++!

Progres lectie:

🎯

Obiectivul lectiei

In Lectia 1 ai inteles DE CE avem nevoie de functii. Acum inveti CUM sa le scrii corect, de la zero.

Dupa aceasta lectie vei putea:

Sa explici sintaxa completa a unei functii
Sa explici functii void — "fa ceva, dar nu da nimic inapoi"
Sa aplici functii cu tip returnat — "calculeaza si da-mi rezultatul"
Sa aplici ce este un prototip de functie
Sa aplici ordinea conteaza

Incearca singur!

🎯 INCEARCA

Scrie prima ta functie!

Nu trebuie sa intelegi totul acum. Copiaza, ruleaza si observa structura. Dupa aceea o explicam pas cu pas.

Misiunea ta (5 minute):

Copiaza codul de mai jos si lipeste-l pe OneCompiler. Apasa Run.

#include <iostream>
using namespace std;

// Aceasta este o FUNCTIE - o comanda creata de tine!
int dublu(int x) {
    return x * 2;
}

int main() {
    cout << "Dublul lui 5 = " << dublu(5) << endl;
    cout << "Dublul lui 12 = " << dublu(12) << endl;
    cout << "Dublul lui 100 = " << dublu(100) << endl;

    return 0;
}

▶ Deschide OneCompiler

Adauga inca un apel: cout << dublu(7); in main. Ce rezultat obtii?

Schimba formula din functie: in loc de x * 2, pune x * 3. Ruleaza. Ce se intampla cu toate rezultatele? De ce?

Creeaza o noua functie dupa modelul lui dublu. Numeste-o patrat si fa-o sa returneze x * x. Apeleaz-o din main cu valoarea 4. Ce afiseaza?

🌟 BONUS: Scrie o functie void salut() care nu returneaza nimic, doar afiseaza "Salut, lume!" cu cout. Apeleaz-o din main.

▶ Blocat la pasul 3? Click aici pentru un indiciu

Cand schimbi x * 2 in x * 3 in interiorul functiei, toate apelurile se schimba automat.

Asta e puterea functiilor: schimbi intr-un singur loc, iar efectul se propaga peste tot.

▶ Blocat la pasul 4? Click aici

Scrie functia patrat inaintea lui main, la fel ca dublu:

int patrat(int x) { return x * x; }

Apoi in main scrie: cout << patrat(4); — va afisa 16.

▶ Blocat la BONUS? Click aici

O functie void nu returneaza nimic. Nu are return cu valoare:

void salut() { cout << "Salut, lume!" << endl; }

In main o apelezi simplu: salut(); — fara cout in fata!

Sintaxa completa a unei functii

O functie in C++ are 4 componente obligatorii: tipul returnat (ce fel de valoare da inapoi), numele (cum o chemam), parametrii (ce date primeste), si corpul (ce face cu acele date).

Gandeste-te la o functie ca la o reteta de bucatarie: are un nume ("Tort de ciocolata"), ingrediente (parametri), pasi de urmat (corpul), si un rezultat final (valoarea returnata).

Formula generala

tip_returnat numeFunctie(tip parametru1, tip parametru2) {
    // corpul functiei - ce face
return rezultat;  // doar daca tip_returnat NU e void
}

Functii void — "fa ceva, dar nu da nimic inapoi"

O functie void executa o actiune (afiseaza ceva, modifica o variabila globala), dar nu returneaza nicio valoare. Nu poti scrie x = functieVoid(); pentru ca nu da nimic inapoi.

Functie void - doar afiseaza

void afiseazaSalut() {
    cout << "Salut! Bine ai venit!" << endl;
    // nu are return cu valoare
}

// In main:
afiseazaSalut();  // Apel direct, fara cout

Functii cu tip returnat — "calculeaza si da-mi rezultatul"

O functie cu tip returnat (int, float, bool, char) calculeaza ceva si da inapoi o valoare prin return. Poti folosi rezultatul in calcule, il poti afisa, sau il poti stoca intr-o variabila.

Functii cu diferite tipuri returnate

// Returneaza un numar intreg
int dublu(int x) {
    return x * 2;
}

// Returneaza un numar cu zecimale
float media(float a, float b) {
    return (a + b) / 2;
}

// Returneaza adevarat/fals
bool estePar(int n) {
    return (n % 2 == 0);
}

// Returneaza un caracter
char primaLitera() {
    return 'A';
}

// In main:
int r = dublu(5);          // r = 10
cout << media(8.0, 6.0);  // Afiseaza: 7
if (estePar(4))            // true
    cout << "Par!";

Ce este un prototip de functie?

Un prototip (sau declaratie) este o "promisiune" facuta compilatorului: "Aceasta functie exista, are acest tip si acesti parametri. O sa-ti arat corpul mai tarziu."

Prototipul se scrie inainte de main si se termina cu punct si virgula (;). Definitia completa (cu corpul) se scrie dupa main.

Ordinea conteaza!

In C++, compilatorul citeste codul de sus in jos. Daca apelezi o functie in main, compilatorul trebuie sa fi vazut deja fie definitia completa, fie cel putin prototipul al acelei functii.

Daca pui definitia functiei DUPA main fara prototip, compilatorul va spune: "Nu stiu ce este dublu!"

Ce identifica unic o functie?

Semnatura unei functii este combinatia dintre numele functiei si tipurile parametrilor sai. Semnatura este ca un CNP al functiei — o identifica unic.

Doua functii pot avea acelasi nume daca au parametri diferiti (acest lucru se numeste supraincarcarea functiilor, dar o vei invata mai tarziu).

Semnatura = Nume + Tipuri parametri

// Semnatura: dublu(int)
int dublu(int x) { return x * 2; }

// Semnatura: media(float, float)
float media(float a, float b) { return (a + b) / 2; }

// Semnatura: afiseazaNota(int, string)
void afiseazaNota(int nota, string elev) {
    cout << elev << ": " << nota << endl;
}

Reguli pentru nume bune de functii

Numele unei functii trebuie sa spuna ce face acea functie. Un nume bun face codul sa se citeasca aproape ca o propozitie in limba romana.

Regula	Exemplu bun ✅	Exemplu rau ❌
Incepe cu verb	calculeazaSuma	suma
Foloseste camelCase	afiseazaNote	afiseaza_note
Fi descriptiv	verificaParitate	vp
Fara diacritice	calculeazaMedia	calculeazăMedia
Fara spatii/caractere speciale	esteNrPrim	este nr prim

Program cu mai multe functii — ruleaza-l!

Acest program combina tot ce ai invatat: o functie void, o functie cu return int, o functie cu return float, si organizare cu prototipuri.

Program complet - ruleaza-l!

#include <iostream>
using namespace std;

// PROTOTIPURI (declaratii)
void afiseazaTitlu();
int dublu(int x);
float media(float a, float b);
bool estePar(int n);

int main() {
    afiseazaTitlu();

    int numar = 7;
    cout << "Numarul: " << numar << endl;
    cout << "Dublul: " << dublu(numar) << endl;
    cout << "Media cu 13: " << media(numar, 13) << endl;

    if (estePar(numar))
        cout << numar << " este par" << endl;
    else
        cout << numar << " este impar" << endl;

    return 0;
}

// DEFINITII (implementari)
void afiseazaTitlu() {
    cout << "=== Programul meu ===" << endl;
}

int dublu(int x) {
    return x * 2;
}

float media(float a, float b) {
    return (a + b) / 2;
}

bool estePar(int n) {
    return (n % 2 == 0);
}

▶ Ruleaza pe OneCompiler

Exercitii practice

Exercitiul 1 (Nivel minim) - Analiza functiilor

Raspunde la urmatoarele intrebari despre declararea functiilor:

Care sunt cele 4 componente ale unei functii C++? Da un exemplu de functie care le contine pe toate.
Explica diferenta intre o functie void si o functie cu tip returnat int. Cand folosim fiecare? Da cate un exemplu.
Ce este un prototip de functie? De ce are nevoie compilatorul de el? Priveste cele doua linii de mai jos si spune care este prototipul si care este definitia: int patrat(int x); si int patrat(int x) { return x * x; } — explica cu cuvintele tale diferenta.

Raspunde numerotat: 1. ... 2. ... 3. ...

Exercitiul 2 (Nivel standard) - Programeaza cu functii

Cerinta: Scrie un program C++ care contine urmatoarele functii (folosind prototipuri inainte de main si definitii dupa main):

void afiseazaLinie() — afiseaza o linie de 20 de cratime: --------------------
int suma(int a, int b) — returneaza suma a doua numere
bool estePositiv(int n) — returneaza true daca n > 0, false altfel

In main, apeleaza fiecare functie cu valori concrete si afiseaza rezultatele.

Exemplu output:

--------------------
Suma: 15
5 este pozitiv: da
--------------------

Indicii:

Scrie cele 3 prototipuri dupa using namespace std;
In main, apeleaza afiseazaLinie(); direct (e void!), iar suma() cu cout
Pentru estePositiv, poti folosi un if sa afisezi "da" sau "nu"

Exercitiul 3 (Nivel performanta) - Gaseste si corecteaza greselile

Cerinta: Urmatorul program contine 4 greseli legate de declararea functiilor. Gaseste fiecare greseala, explica de ce e gresit, si scrie varianta corecta.

#include <iostream>
using namespace std;

int main() {
  triplu(int n) {
    return n * 3;
  }
  cout << triplu(5);

  void salut();
  { cout << "Buna!"; }
  cout << salut();
  return 0;
}

Indicii (4 greseli distincte):

Greseala 1: Unde este scrisa functia triplu? O functie nu poate fi definita in interiorul altei functii (de ex. in main) — trebuie sa fie in afara lui main.
Greseala 2: Ce lipseste la inceputul antetului lui triplu? Orice functie care returneaza o valoare trebuie sa aiba tipul returnat explicit (de ex. int) inainte de nume.
Greseala 3: void salut(); urmat imediat de un bloc { ... } pe linia urmatoare NU este o definitie de functie — este un prototip separat de un bloc anonim. Definitia corecta este void salut() { cout << "Buna!"; } fara punct si virgula intre antet si corp.
Greseala 4: cout << salut(); este gresit pentru o functie void. Functiile void nu returneaza nicio valoare, deci nu pot fi puse in cout. Apelul corect este simplu: salut();

Cuvinte cheie de folosit: prototip, definitie, tip returnat, void, return, punct si virgula, declarare in afara lui main

Ce ai invatat astazi

Ai invatat sintaxa completa a unei functii
Acum stii functii void — "fa ceva, dar nu da nimic inapoi"
Ai descoperit functii cu tip returnat — "calculeaza si da-mi rezultatul"
Ai explorat ce este un prototip de functie
Ai inteles ordinea conteaza
Ai invatat ce identifica unic o functie
Acum stii reguli pentru nume bune de functii
Ai descoperit program cu mai multe functii — ruleaza-l

Urmatoarea lectie

Continua cu lectia urmatoare pentru a aprofunda cunostintele.

Continua →