V-table

Destructori virtuali
Conversii la atribuirea de obiecte
C++ 11, C++14
Auto-typing
Smart_ptr, dynamic_cast, static_cast
Lambda functions
Referintele, ca si pointerii, sunt variabile care contin adresa unei zone de memorie. Semantic,
ele reprezinta aliasuri ale unor variabile existente. Referintele sunt legate de variabile la declaratie si
nu pot fi modificate pentru a referi alte zone de memorie.
Sintaxa folosita pentru declararea unei referinte este:
Tip & referinta = valoare;
Proprietatile cele mai importante ale referintelor sunt:
referintele trebuie sa fie initializate la declaratie (spre deosebire de pointeri care pot fi
initializati in orice moment);
dupa initializare, referinta nu poate fi modificata pentru a referi o alta zona de memorie
(pointerii pot fi modificati pentru a referi alta zona) ;
intr-un program C++ valid nu exista referinte nule Referintele utilizate in principal pentru
transmiterea parametrilor in functii.
Trimiterea parametrilor in functii
prin valoare: valorile parametrilor sunt copiate pe stiva; modificarile efectuate de functie
asupra parametrilor nu se vor reflecta in apelant
prin adresa: se copiaza pe stiva adresele de memorie unde se afla datele corespunzatoare
parametrilor; modificarile efectuate de functie vor fi vizibile si in apelant.
Exemple de transmitere parametri:

Functie
Prin valoare:
void Inc(int i)
{
i++;
}

Prin referinta:
void IncReferinta(int &i)
{

i++;
}

Apel
int i = 10;
Inc(i);
cout << i;
Rezultat: 10
int i = 10;
IncReferinta(i);
cout << i;
Rezultat: 11

Prin pointeri:
void IncPointer(int *pi)
{
(*pi)++;
}

int i = 10;
IncPointer(&i);
cout << i;
Rezultat: 11

Pointeri si referinte constante

Modificatorul const poate fi folosit pentru a declara pointeri constanti sau pointeri la zone
constante.
Pointerii constanti sunt pointeri care nu-si pot modifica adresa referita. Sintaxa folosita este:
tip * const pointer_ct = adresa;

In cazul pointerilor constanti, initializarea la declarare este obligatorie.

Exemplu:
// declarare si initializare
// pointer constant
int * const pConstant = &i;
// modificarea continutului este permisa
(*pConstant) = 5;
// modificarea adresei nu este permisa
pConstant = &j; // => eroare de compilare

Pointerii la zone de momorie constante sunt pointeri prin intermediul carora nu se poate modifica
continutul zonei referite.
Sintaxa de declarare este:
tip const * pointer_zona_ct;

Exemplu:
// declarare pointer la zona constanta
int const * pZonaCt;
// modificarea adresei referite
// este permisa
pZonaCt = &i;
pZonaCt = &j;
// modificarea continutului nu este permisa
(*pZonaCt) = 7; // => eroare de compilare

Cele doua forme pot fi folosite simultan pentru a declara pointeri constanti la zone de memorie
constanta:
tip const * const pointer_ct_zona_ct;

In acest caz nu poate fi modificata nici adresa referita, nici constinutul acesteia.

Referintele sunt implicit echivalente cu un pointer constant (adresa referita nu poate fi

modificata). In cazul lor, modificatorul const poate fi utilizat pentru a crea referinte prin
intermediul carora nu se pot efectua modificari asupra continutului. Sintaxa utilizata este:
tip const& referinta_ct;

Comportamentul este echivalent cu al pointerilor constanti la zone de memorie constanta

(referinta va putea fi utilizata numai pentru citirea valorii referite).

Supraincarcarea functiilor
C++ permite sa avem mai multe functii cu acelasi nume. Cand rulam programul, compilatorul
C++ determina care functie trebuie apelata in functie de numarul si tipul parametrilor pe care
intructiunea de apelare ii transmite functiei.
Exemplu:
#include "stdafx.h"
using namespace std;
int suma(int *matrice, int nr_element)
{
int rezultat=0;
int nr;
for (nr=0; nr<nr_element; nr++)
rezultat+=matrice[nr];
return rezultat;
}
double suma(double *matrice, int nr_element)
{
double rezultat=0;
int nr;
for (nr=0; nr<nr_element; nr++)
rezultat+=matrice[nr];
return rezultat;
}
void main()
{
int a[5]={1,2,3,4,5};
double b[4]={1.11,2.22,3.33,4.44};
cout<<"suma valorilor int este "<<suma(a,5)<<endl;
cout<<"suma valorilor double este "<<suma(b,4)<<endl;
}
Functiile pot avea acelasi tip, dar atunci trebuie sa difere numarul de parametrii, iar daca au acelasi
numar de parametrii trebuie neaparat sa fie de alt tip.
Supraincarcarea unui operator
Prin supradefinirea operatorilor se pot realiza operatii specifice unui nou tip de date la fel de
usor ca in cazul tipurilor de date standard.
Cand supraincarcati un operator trebuie sa continuati sa utilizati operatorul in formatul sau
standard, adica daca supraincarcati operatorul (+) acesta trebuie sa utilizeze operatorul sub forma
operand+operand. Puteti sa supraincarcati doar operatorii existenti. C++ nu va permite definirea unor
operatori proprii. Operatorul supraincarcat se aplica numai instantelor clasei specificate. De exemplu,
daca avem o clasa Sir si am incarcat operatorul plus astfel incat operatorul sa concateneze doua siruri
de caractere sir_nou=sir1+sir2; daca utilizati operatorul plus supraincarcat, cu doua valori intregi,
supraincarcarea nu se va aplica. Operatori care NU pot fii supraincarcati sunt . .* :: ?:
NU puteti utiliza o functie friend pentru supraincarcarea urmatorilor operatori = [ ] ( ) ->
Adesea functiile operator returneaza un obiect al clasei asupra caruia opereaza. Atunci cand
supraincarcati un operator unar lista de argumente trebuie sa fie goala, iar cand supraincarcati un
operator binar lista de argumente trebuie sa contina un singur parametru.

Sintaxa:
tip_return nume_clasa operator #(lista_argumente){
//operatii
}
Supradefinirea se poate face folosind:
functii membre nestatice
functii prietene

Incapsularea se refera la protectia datelor unui obiect. Utilizatorul ( tot programator ) al unui
obiect sa nu aibe acces direct la datele clasei;

cand folosesti class{ }; tot ce e inauntru acestei clase este default privat, adica doar
functiile din interiorul clasei pot accesa datele;
class Student
{
string mNume;
public:
float medie;
private:
int x;
}

mNume si x sunt variabile private, iar medie e public ( nu e recomandat sa faci public o variabila )
Membrii public ai unei clase de baz pot fi accesai de orice funcie din program
Membrii private al unei clase de baz sunt accesibili doar funciilor membre sau prietenilor clasei
Membrii protected ai unei clase de baz pot fi accesai doar de

membrii i de prietenii clasei de baz

de membrii i prietenii claselor derivate

Datele protected depesc ideea de ncapsulare pentru c o schimbare a membrilor protected din
clasa de baz poate influena toate clasele derivate

se recomand ca datele membre s fie declarate private

protected trebuie folosit numai atunci cnd este strict necesar

Atributul din
clasa de baza

Modificator
de acces

Accesul mostenit
de clasa derivata

Accesul din
exterior

private
protected
public

private
private
private

inaccesibil
private
private

inaccesibil
inaccesibil
inaccesibil

private
protected
public

public
public
public

inaccesibil
protected
public

inaccesibil
inaccesibil
accesibil

Constructorul este o metod special a unei clase, care este

membru al clasei
respective i are acelai nume ca i clasa. Constructorii sunt apelai atunci
cnd se instaniaz
obiecte din clasa respectiv, ei asigurnd iniializarea corect a tuturor
variabilelor membru
ale unui obiect i garantnd c iniializarea unui obiect se efectueaz o
singur dat.
Constructorii se declar, definesc i utilizeaz ca orice metod uzual,
avnd
urmtoarele proprieti distinctive:
- poart numele clasei creia i aparin;
- nu pot returna valori; n plus (prin convenie), nici la definirea, nici
la declararea lor nu
poate fi specificat void ca tip returnat;
- adresa constructorilor nu este accesibil utilizatorului; expresii de
genul &X :: X()
nu sunt disponibile;
- sunt apelai implicit ori de cte ori se instaniaz un obiect din
clasa respectiv;
- n caz c o clasa nu are nici un constructor declarat de ctre
programator, compilatorul
va declara implicit unul. Acesta va fi public, fr nici un parametru, i
va avea o list
vid de instruciuni;
- n cadrul constructorilor se pot utiliza operatorii "new" si "delete",
- constructorii pot avea parametrii.
O clas poate avea orici constructori, ei difereniindu-se doar prin tipul i
numrul
parametrilor. Compilatorul apeleaz constructorul potrivit n funcie de
numrul i tipul

parametrilor pe care-i conine instanierea obiectului.

Tipuri de constructori
- constructor implicit (default constructor);
- constructor de copiere (copy constructor);
O clas poate conine, de asemenea, constructori de copiere.
Constructorul de
copiere generat implicit copiaz membru cu membru toate variabilele
argumentului n cele ale
obiectului care apelaz metoda. Compilatorul genereaz implicit un
constructor de copiere n
fiecare clas n care programatorul nu a declarat unul n mod explicit.
Constructori de copiere - Utilizare

in Crearea de obiecte cu iniializare, pornind de la un obiect care exist

(IdClasa ob2=ob1).
in Apelul unei funcii care lucreaz cu obiecte transferate prin valoare,
cnd este nevoie de crearea unei copii a obiectului pe stiv (cazul f(ob);)
in Returnarea dintr-o funcie a unui obiect prin valoare (return ob;)

Exemplu:
class X {
X (X&); // constructor de copiere
X (void); // constructor implicit
};

Apelarea constructorului de copiere se poate face n urmtoarele moduri:

X obiect2 = obiect1;

sau sub forma echivalent:

X obiect2 (obiect1);

Destructorii
Destructorul este complementar constructorului. Este o metod care are
acelai nume
ca i clasa creia i aparine, dar este precedat de ~. Dac constructorii
sunt folosii n
special pentru a aloca memorie i pentru a efectua anumite operaii (de
exemplu:
incrementarea unui contor al numrului de obiecte), destructorii se
utilizeaz pentru eliberarea
memoriei alocate de constructori i pentru efectuarea unor operaii
inverse (de exemplu:
decrementarea contorului).
Exemplu:
class exemplu
{
public :

exemplu (); // constructor

~exemplu (); // destructor
};

Destuctorii au urmtoarele caracteristici speciale:

- sunt apelai implicit n dou situaii:
1. cnd se realizeaz eliberarea memoriei alocate dinamic
pentru memorarea unor obiecte, folosind operatorul delete
(a se vedea linia 10 din programul de mai sus);
2. la prsirea domeniului de existen al unei variabile
Dac n al doilea caz este vorba de variabile globale sau definite n main,
distrugerea lor se face dup ultima instruciune din main, dar nainte de
ncheierea execuiei programului.
Parametrii impliciti
Argumentele implicite sunt transmise parametrilor definiiei funciei automat, dac apelul
funciei nu conine argumentele respective

//Acest program demonstreaza modul de utilizare a argumentelor implicite

#include<iostream>
using namespace std;

//Prototipul functiei cu argumentele implicite

void suma(int=5, int=5 );

//Functia principala main

int main()
{
suma(); // apelul functiei utilizeaza argumentele implicite
cout << endl;
suma(25); // apelul functiei utilizeaza argumentul implicit pentru
num2
cout << endl;
suma(15,30); // apelul functiei utilizeaza argumentele 15 si 30

cout << endl;

return 0;
}

//Definitia functiei suma

//Aceasta functie afiseaza suma a doua numere
void suma(int num1, int num2)
{

cout << "Suma = " << num1+num2;

cout << endl;

Mostenirea claselor
Mecanismul prin care o clas preia structura (datele membru) i comportamentul (metodele)
unei alte clase la care adaug elemente specifice.

Clas de baza = clasa de la care se preia structura i comportamentul

Clasa derivat = clasa care preia structura i comportamentul

Avantaje:

posibilitatea reutilizarii codului

obinerea extensiei unei clase far a fi necesar o recompilare a clasei
initiale;
utilizarea polimorfismului n timpul executiei programului prin folosirea
functiilor virtuale

Tipuri de Motenire

Motenire simpl clasa derivat preia caracteristicile i metodele unei

singure clase de baz
Motenire multipl - clasa derivat preia caracteristicile i metodele
de la mai multe clase de baz

Functii de tip const

O functie constanta nu poate modifica obiectul prin care a fost apelata.

class A
{
int m;
void f() const
{
// attempt to modify this object
m = 1; // Error
}
};

Alfel spus, specificatorul const face ca poiterul this din corpul functiei sa fie de tip pointer to const.
In exemplul echivalent [2], functia A::f foloseste pointerul this pentru a ilustra acest lucru.
class A
{
int m;
void f() const
{
(*this).m = 1; // Error (l-value specifies const object)
}
};

Overload (supraincarcare)
- utilizarea aceluiasi nume de metoda impreuna cu liste diferite de argumente
ex: void f(string nume, int pid){} i
void f(int pid, string nume){}
Override (suprascriere)
- se foloseste pentru a modifica o metoda sau o proprietate si furnizeaza o noua
implementare a unui membru mostenit dintr-o clasa de baza
- metoda suprascrisa si metoda de suprascriere trebuie sa aiba aceeasi signatura (tip si
numar de parametrii)
ex: public virtual void Display(); - in clasa de baza
public override void Display(); - in clasa derivata
!!! O functie virtuala nu poate fi declarata private deoarece nu ar mai putea fi supraincarcata in clasa
derivata
OVERLOADING se rezolva la compile time iar OVERRIDING la runtime!!!!

Virtual
- folosit in declararea unei metode sau a unei proprietati ==> membrii virtuali
- implementarea unui membru virtual poate fi schimbata prin suprascrierea membrului intr-o clasa
derivata.
ex:
class Baza
{
public virtual void Afiseaza()
{
Console.WriteLine("Apelul functiei Afiseaza din clasa de
baza\n");
}

}
class Derivata : Baza
{
public override void Afiseaza()
{
Console.WriteLine("Apelul functiei Afiseaza din clasa
derivata");
}
}

Namespace

modul in care C++ gestioneaza "complexitatea" si name-clash-urile;

Ne permite sa grupam anumite functii, clase, etc. in pachete, fara a ne stresa ca altcineva,
intr-o alta librarie a numit functia la fel;
Notiunea de namespace vine sa rezolve un neajuns al limbajului C, unde majoritatea librariilor
trebuiau sa isi prefixeze functiile in clar, pentru a evita name-clash-ul cu alte librarii (sa nu
existe doua functii cu acelasi nume).
Functii si date statice

Fiecare obiect de tip clasa are propriile lui copii ale tuturor membrilor acelei clase. Este posibila
definirea de membrii care sa fie folositi n comun de catre toate obiectele clasei.
Datele statice exista ntr-o singura copie, comuna tuturor obiectelor. Crearea, initializarea si
accesul la aceste date statice sunt total independente de obiectele clasei.
Funcii membre statice

Funciile membre statice se utilizeaz n scopul de a sugera faptul c acioneaz asupra

instanelor clasei vzute ca un ntreg i nu asupra instanelor clasei n mod individual.
Pot aciona doar asupra atributelor statice (ale claselor);
Nu pot aciona asupra atributelor obiectului curent (deoarece nu li se transmite pointerul this)
Nu pot apela dect funcii membre statice

Variabila membra statica

variabila membra statica nu apartine nici unui obiect. Apartine clasei

Chiar daca nu exista obiecte instantiate, variabila membru statica exista alocata
Accesibilitatea se face folosind numele clasei si access-scope-operatorul
Practic este ca o variabila globala insa este accesibila doar prin intermediul clasei
Ca orice variabila membru, poate fi public sau private
Este obligatoriu sa fie redeclarat (optional si initializata) in afara calsei:
int Vector::counter = 0;

Name mangling

C++ diferentiaza functiile dupa nume si parametrii acesteia. Acesta genereaza un nume nou pentru
fiecare functie. Noul nume depinde de numele original al functiei si de parametrii acesteia si este
UNIC. Daca parametrii sau numarul lor se schimba atunci compilatorul va genera un alt nume, chiar
daca numele propriu-zis al functiei este acelasi. Acest proces de codificare al numelor functiilor se
numeste NAME MANGLING si este compiler dependent.
Funciile friend sunt funcii asociate unor clase care au acces la datele i metodele protejate ale
acelor clase dei nu sunt funcii membre ale acelei clase.
Funciile friend membre ale altor clase:

Sunt funcii membre ale unei clase ce au acces la datele membru protejate ale unei alte clase.
Declararea unei funcii friend se face incluznd prototipul ei, precedat de cuvntul cheie
friend, n clasa n care se dorete accesul

Clase friend

Dac dorim ca toate metodele dintr-o clas IdClasaB s aibe acces asupra tuturor datelor
membre protejate ale unei alte clase IdClasaA atunci declarm clasa IdClasaB ca fiind clas
friend (prieten) pentru clasa IdClasaA

Sintaxa declarrii claselor prietene este urmtoarea:

class IdClasaB; //declarare a clasei IdClasaB inaintea

definirii clasei
IdClasaA class IdClasaA
{
friend class IdClasaB;
};

Relaia de prietenie dintre dou clase nu este reflexiv: Dac clasa IdClasaA este clas prieten
a clasei IdClasaB, atunci nu i reciproca este valabil
Relaia de prietenie nu este tranzitiv: dac clasa IdClasaA este clas prieten clasei IdClasaB,
iar IdClasaB este clas prieten clasei IdClasaC, asta nu implic faptul c IdClasaA este clas
prieten a clasei IdClasaC.
Relaia de prietenie nu se motenete n clasele derivate.

Polimorfismul este capacitatea unor entiti de a lua forme diferite.

Tipuri de polimorfism
1. Polimorfismul parametric - Overload (supraincarcare) mecanismul prin care putem
defini o metod cu acelai nume n aceai clas, funcii care trebuie s difere prin numrul
i/sau tipul parametrilor. Selecia funciei se realizeaz la compilate (legarea timpurie
(early binging)).
2. Polimorfismul de motenire mecanismul prin care o metod din clasa de baz este
redefinit cu aceiai parametri n clasele derivate. Selec ia func iei se va realiza la rulare
(legarea ntrziat (late binding, dynamic binding, runtime binding)).
n limbajul C++ este implementat cu ajutorul funciilor virtuale.
3. Functii template

Funcii virtuale
O funcie virtual este o funcie membr a unei clase care poate fi nlocuit, n momentul execu iei
programului, cu o funcie membru din clasa derivat.
Funciile virtuale pure sunt funcii virtuale ce sunt doar declarate n clasa de baz, urmnd ca acestea
sa fie definite n clasele derivate.

Functii template
O funcie template (ablon, generic) este un tipar utilizat de compilator pentru a construi
automat diverse funcii. n Se utilizeaz pentru implementarea de funcii care difer doar prin tipul
parametrilor
Clase Template
O clas template (generic) este un model (un ablon) utilizat pentru generarea unor clase
concrete, clase ce difer prin tipul anumitor date membre.

Pointer-ul this nu este un membru ascuns al unei clase, ci un parametru introdus de

compilator la toate functiile non-statice.
In corpul unei functii membre nestatice, cuvantul cheie this este expresie non-lvalue a carei valoarea
este adresa obiectului pentru care a fost apelata functia. Tipul lui this intr-o functie a unei clase X este
X*. Daca functia membra e declarata const, atunci tipul sau e const X*;
Supraincarcarea operatorilor

Prin supradefinirea operatorilor se pot realiza operatii specifice unui nou tip de date la fel de
usor ca in cazul tipurilor de date standard.
Cand supraincarcati un operator trebuie sa continuati sa utilizati operatorul in formatul sau
standard, adica daca supraincarcati operatorul (+) acesta trebuie sa utilizeze operatorul sub
forma operand+operand.
Puteti sa supraincarcati doar operatorii existenti. C++ nu va permite definirea unor operatori
proprii.
Operatorul supraincarcat se aplica numai instantelor clasei specificate. De exemplu, daca
avem o clasa Sir si am supraincarcat operatorul plus astfel incat operatorul sa concateneze
doua siruri de caractere sir_nou=sir1+sir2; daca utilizati operatorul plus supraincarcat, cu doua
valori intregi, supraincarcarea nu se va aplica. Operatorii care NU pot fii supraincarcati
sunt . .* :: ?:
NU puteti utiliza o functie friend pentru supraincarcarea urmatorilor operatori = [ ] ( ) ->
Adesea functiile operator returneaza un obiect al clasei asupra caruia opereaza.
Atunci cand supraincarcati un operator unar lista de argumente trebuie sa fie goala, iar cand
supraincarcati un operator binar lista de argumente trebuie sa contina un singur parametru.
Sintaxa:
tip_returnat nume_clasa operator #(lista_argumente)

{ //operatii }
Supradefinirea se poate face folosind:

functii membre nestatice

functii prietene

Tratarea exceptiilor
Suportul sintactic C++ pentru tratarea excepiilor se rezum la trei cuvinte
cheie, a cror semantic preliminar este prezentata n tabelul urmtor:

Cuvntul
cheie
try
throw
catch

Semnificaie
Delimiteaz o poriune de cod n care se instituie controlul
sistemului asupra excepiilor n timpul rulrii.
Lanseaz o excepie de un anumit tip
Capteaz o excepie lansat

Pasii care trebuiesc in general urmati in vederea tratarii exceptiilor in cadrul programelor C++ sunt:
1. se identifica acele zone din program in care se efectueaza o operatie despre care se cunoaste ca
ar putea genera o exceptie, si se marcheaza in cadrul unui bloc de tip try. In cadrul acestui
bloc, se testeaza conditia de aparitie a exceptiei, si in caz pozitiv se semnaleaza aparitia
exceptiei prin intermediul cuvantului cheie throw;
2. se realizeaza blocuri de tip catch pentru a capta exceptiile atunci cand acestea sunt intalnite.
Blocurile catch urmeaza un bloc try, in cadrul carora sunt tratate exceptiile.

Late binding

mecanism prin care compilatorul, in momentul in care nu poate determina implementarea

unei metode in avans, lasa la latitudinea JVM-ului (masinii virtuale) alegerea

implementarii potrivite, in functie de tipul real al obiectului. Acesta legare a implementarii

de numele metodei la momentul executiei sta la baza polimorfismului.

Clase abstracte
Dorim sa stabilim interfata comuna pentru a putea crea functionalitate diferita pentru fiecare
subtip si pentru a sti ce anume au clasele derivate in comun.
O clasa cu caracteristicile enumerate mai sus se numeste abstracta. Cream o clasa abstracta atunci
cand dorim sa:

manipulam un set de clase printr-o interfata comuna

reutilizam o serie metode si membrii din aceasta clasa in clasele derivate.

Metodele suprascrise in clasele derivate vor fi apelate folosind dynamic binding (late binding).
Nu exista instante ale unei clase abstracte, aceasta exprimand doar un punct de pornire pentru
definirea unor instrumente reale. De aceea, crearea unui obiect al unei clase abstracte este o eroare,
compilatorul Java semnaland eroare in acest caz.
abstracte:
Clase abstracte in contextul mostenirii
O clasa care mosteneste o clasa abstracta este
ea insasi abstracta daca nu
implementeaza toate metodele abstracte ale
clasei de baza. Putem defini clase abstracte
care mostenesc alte clase abstracte si tot asa. O
clasa care poate fi instantiata (nu este
abstracta) si care mosteneste o clasa abstracta
trebuie sa implementeze (defineasca) toate
metodele abstracte pe lantul mostenirii (ale
tuturor claselor abstracte care ii sunt "parinti").
Este posibil sa declaram o clasa abstracta
fara ca ea sa aiba metode abstracte. Acest lucru
este folositor cand declaram o clasa pentru care
nu dorim instante (nu este corect conceptual sa
avem obiecte de tipul acelei clase, chiar daca
definita ei este co mpleta). Iata cum putem sa
modificam exemplul instrument cu metode

Interfata reprezinta un mecanism prin care o clasa C utilizeaza date si servicii oferite de instante ale
unor clase A1, A2,. . ., An, in mod independent de acestea, accesand clasele Ai prin intermediul unei
interfete.

Clase vs structuri
O structura permite punerea la un loc a mai multor tipuri de date pentru a forma un nou tip de data.
Clasa=structura in care membrii nu mai sunt accesibili by default ( asa cum sunt cei dintr-o
structura ) , acestia primind cate un calificativ precum private,public sau protected. De asemenea,
clasele pot contine si functii.

Standard Template Library

STL se bazeaza pe trei concepte centrale: containeri, iteratori si algoritmi deja implemantati;
o

Clase container: liste, vectori, mao-uri, hash-map-uri, set-uri, stack-ri

Clasa de string-uri: alocare automata de spatiu, cautari, concatenari etc

Algoritmi: sortari, cautari, rotatii, merge-uri, min/max etc.

Inclus in C++ Standard Library

Inclus in namespace-ul std

Clasele si functiile sunt bazate in general pe template-uri

Agregarea

Numita si compunere, agregarea reprezinta pur si simplu prezenta unei referinte la un obiect intr-o alta
clasa. Acea clasa practic va refolosi codul din clasa corespunzatoare obiectului. Exemplu:
class Page {
private String content;
public int no;
public Page(String c, int no) {
this.content = c;
this.no
= no;
}
}
class Book {
private Page[] pages;
public Book(int dim, String title) {
pages = new Page[dim];
for (int i=0; i < dim; i++)
pages[i] = new Page("Pagina " + i, i);
}
}