Deoarece C++ este un superset al ISO C, stilul de programare procedural (separarea intre functii si datele pe care acestea le manipuleaza) poate fi utilizat in continuare. Sunt aduse imbunatiri care au rolul de a usura design-ul si programarea.

  1. Un nou stil pentru comentarii
  2. Tipul de date bool
  3. Etichetele sunt nume de tipuri
  4. Declararea variabilelor acolo unde este necesar
  5. O noua conventie pt. denumirea fisierelor header
  6. Tipul referinta
  7. Un nou operator de alocare dinamica a memoriei
  8. Functii inline
  9. Parametri impliciti pentru functii
  10. Supraincarcarea functiilor
  1. Un nou stil pentru comentarii

    2. //acesta este un comentariu
  2. Tipul de date bool

    3. Este introdus in limbaj un tip de data predefinit, numit bool, pentru manipularea valorilor logice de adevar (false, true). Operatorii logici (&&, ||, !) au fost modificati astfel incat sa preia argumente si sa returneze rezultate de tip bool. Operatorii relationali (<, >, <=, >=, ==, !=) returneaza si ei valori de tip bool.
    
bool a=true, b=false;
cout << true << false; //1,0
cout << a << b;        //1,0
    Observatii:
    1. ++a si a++ returneaza intotdeauna true!
    2. --a si a-- sunt invalide (eroare la compilare)!
  3. Etichetele sunt nume de tipuri

    4. Etichetele structurilor, uniunilor si enumerarilor sunt nume de tipuri. 
    
struct A {/**/};
A a;
  4. Declararea variabilelor acolo unde este necesar

    5. Variabilele pot fi declarare acolo unde este nevoie de ele (if, for,...)
    
for(int i=0;i<10;i++) //declaratie si initializare
{}
int n=i;              //eroare la compilare; variabila i este in afara scopului sau!
  5. O noua conventie pt. denumirea fisierelor header

    6. S-a renuntat la extensia h; numele fisierelor header ISO C au fost prefixate cu litera c: cstdio, cstdlib, ...
  6. Tipul referinta

    7. O referinta este un alias (un nou nume) pentru o entitate deja existenta (ce are alocata o zona de memorie): 
    
    int  i=5;
    int& j=i;	//j este un alt nume pentru variabila i

    
Observatii:
1. In general, referintele trebuie initializate in momentul declararii.
   Exceptie fac referintele declarate cu extern.
2. Nu sunt permise referinte la referinte!
   Nu sunt permisi pointeri la referinte!
	int p=0;
	int& p1=p;
	int&& p2=p1; 	//eroare la compilare
	int&  p2=p1;	//OK
	int&* p3=&p1;	//eroare la compilare
3. Pot exista referinte la pointeri.
	int* p;
	int*& p1=p;
  7. Nou operator de alocare dinamica a memoriei

    8. In versiunile timpurii ale lui C++ noul operator de alocare a memoriei, NEW, returna un pointer NULL in cazul unei alocari esuate. Standardul C++ a specificat ca NEW genereaza o exceptie std::bad_alloc in cazul unui esec de alocare de memorie; a fost pastrata si versiunea anterioara. Operatorul complementar lui NEW este DELETE.
    
int *p1 = new int;			delete p1;
int *p2 = new(int);			delete p2;
int* p3 = new int[5];			delete [] p3;
int* p4[5] = new int[5];		delete [] p4;

int *p = new int[2];
int *aux = p+1;
*aux = 17;
delete p3; //elibereaza doar prima locatie!
cout << *aux << endl; //afiseaza 17
  8. Functii inline

    9. Apelul unei functii inline este expandat cu corpul functiei, ceea ce face ca functiile inline sa semene cu expresiile macro. Spre deosebire de acestea, expandarea este realizata de catre compilator (si nu de catre preprocesor), executandu-se astfel si o verificare a tipurilor parametrilor (ca in cazul unui apel normal de functie). De remarcat ca inline este doar o cerere; ea poate (sau nu) sa fie indeplinita de catre compilator!
    Deoarece expandarea unei functii inline se produce la compilare, definitia ei trebuie sa fie disponibila in aceasta faza, ceea ce face ca, de obicei, definitiile functiilor inline sa fie plasate in fisierele header!!! Acest fapt este in evidenta contradictie cu regula uzuala care specifica ca fisierele header trebuie sa contina doar declaratii.
  9. Parametri impliciti pentru functii

    10. Este posibil sa se apeleze o functie cu un numar de parametri actuali mai mic decat numarul parametrilor formali. Parametrii lipsa se numesc impliciti (cu valori implicite); ei trebuie sa se regasesca in extrema dreapta a listei parametrilor formali din antetul functiei.
    
void f(int m=0, int n=1){}
f();  	//f(0,1)
f(1); 	//f(1,1)
f(1,2);
  10. Supraincarcarea functiilor

    11. O functie poate fi supraincarcata, adica pot exista mai multe definitii pentru acelasi nume de functie: 
    
double max(double, double);
int    max(int, int);
    Pentru a genera nume unice pentru identificatorii dintr-un program compilatorul de C++ utilizeaza o tehnica de decorare a numelor (name mangling); din acest motiv numele in cod obiect al celor doua functii anterioare sunt distincte (si diferite de numele sursa al functiei, adica max)! 
    
void f(char c); 		//name mangling -> apelabila numai din cod C++
void f(int  n); 		//name mangling -> apelabila numai din cod C++
extern "C" void f(int n);   	//apelabila din cod C++ si C; numele in cod obiect este "f"
extern "C" void f(float n); 	//eroare la compilare; numele in cod obiect este tot "f"