Curs 2

- C onceptele fundam entale ale tehnicii obiectuale (fără legătură cu C++)

o Clase (și obiecte) și odată cu ele:
 A bstractizare (abstraction)
 M oștenire (inheritance)
 P olim orfism (polymorphism)
 Încapsulare (encapsulation)

o Altele, specifice C++

 Încărcarea operatorilor (operator overloading)
 Tratarea excepțiilor (exception)

Caracterizarea C++
o Compilat,
 Obs: API = Application Programming Interface
o Uz-general,
o Case-sensitive,
o Free-form (nu restricționează și nu impune reguli legate de așezarea în
pagină)
o C++ prezintă legare statică (verif. tipurilor de date se face la compilare și
nu la rulare)
o Limbaj de nivel mediu (middle-level) pentru că prezintă atât caracteristici
de nivel înalt (ex. STL) cât și de nivel scăzut (e.g. interacțiunea cu valori
numerice la nivel de bit)
- Suportă programare:
o procedurală (structurată - suportă cod ISO C),
o object-oriented (nativ),
o programare generică (bazată pe șabloane == templates).
- C ca sub-dialect C++ (sau C++ ca super-set al C) => virtual orice program C
este acceptat ca program C++
o Față de C (corolare):
 Regulile de sintaxă și punctuație se păstrează
 Comentariile C sunt acceptate /* */
 Comentarii tipice C++ // (pentru o linie)
 Pe mai multe linii: fiecare linie începe cu //
 Cuvintele-cheie C sunt acceptate + cuvinte-cheie C++
C++ Keywords
Tabelul următor prezintă cuvintele rezervate (keywords) din C++. Ca și în C (și mai
general în orice limbaj de programare bine construit) acestea nu se pot folosi cu rol de
identificatori. Fiecare dintre acestea prezintă un set de reguli tipice și specifice, care
trebuie cunoscute înainte de a putea fi folosite responsabil.
asm else new this auto enum operator throw
bool explicit private true
break export protected try

case extern public typedef

catch false register typeid
char float reinterpret_cast typename
class for return union
const friend short unsigned
const_cast goto signed using
continue if sizeof virtual

default inline static void

delete int static_cast volatile
do long struct wchar_t
double mutable switch while
dynamic_cast namespace template

Tipurile de date C
- Sunt acceptate + tipuri de date specifice (noi):
o bool cu valori posibile true și false D A R : este oarecum incorect să se
considere true identic 1 și false identic 0 pt că 0 și 1 sunt în esență valori
întregi, pe când bool este construit pentru valori (logice) de adevăr.
o wchar_t (caracter extins) e.g. L'abc' // utf-8 (UNICODE)
o class
o referința (&) în esență un alias (alt nume) al variabilei respective
- Tipuri definite de utilizator (typedef)

Vizibilitatea (scope) și durata de viață (lifetime) se păstrează

o local (inclusiv parametrii formali - declarativi - ai funcțiilor)
o global (în afara oricărui corp de instrucțiuni)
 o auto - variabilele locale sunt automatice (auto) - create la începutul fiecărui
bloc și distruse la ieșirea din acel bloc de instrucțiuni
o register - (v. CISC/RISC) variabile pentru care se dorește rezervarea unuia
dintre registrele procesorului => NU are adresă (nu pot folosi operatorul
de preluare a adresei: &)
o static - variabila locală se păstrează între intrările și ieșirile dintr-un corp
de instrucțiuni (asta înseamnă că locația de memorie este permanentă)
 aplicată variabilelor globale => vizibilitatea este limitată la
entitatea program (fișierul) în care este declarată => NU poate fi
exportată (e.g. prin modularizarea programului se exclude
posibilitatea ca acea variabilă să poată fi cunoscută între modulele
program)
o - prin contrast cu static oferă acelei variabile posibilitatea de a fi
extern

cunoscută oricărui modul program folosit

o mutable (tipic C++) - specific obiectelor (instanțe ale unei clase); permite
modificarea unui obiect prin intermediul funcțiilor de tip const ce aparțin
clasei respective.

Instrucțiuni ISO C
- de ciclare se păstrează (for, while, do-while)

- goto label se păstrează (saltul condiționat în program, la instrucțiunea marcată

prin label)
- Instrucțiunile de decizie (if și if cu ramuri else, switch)

Funcții
- Declarația și definiția funcțiilor - similar cu C (prototip și corp);
o Dacă este cazul unui modul program (am funcție main()) atunci:
 Declar (anunț) funcția: nume, tip retur, parametri (formali) -
prototip
 main()
 Definesc funcția: ceea ce face acea funcție - corpul funcției
o Dacă scriu un modúl program (nu am main()), atunci:
 declarația funcției (prototipul) apare într-un fișier antet (.h)
- Definiția funcției (corpul) este cuprinsă într-un fișier sursă (.cpp)
o Funcții cu apel referință == ca efect cu funcțiile cu argument pointer
// function definition to swap the values
 void swap(int &x, int &y) // swap(a, b);
{
int temp;
temp = x; /* save the value at address x */
x = y; /* put y into x */
y = temp; /* put x into y */
return;
}

Vectori
- Vectorii C se păstrează (varianta C++ nativă: string) și sunt acceptați în
programe C++
o Numele vectorului == adresa primului element
o Aritmetica pointerilor v[i] == *(v+i)
o Indexarea cu index minim zero (0)
- Șirurile C se păstrează + clasa string
o funcțiile de manipulare a șirurilor din C sunt valabile și apar în antetul
cstring (!)
 #include<cstring>
o Apare clasa string
Exem plu:
#include <iostream>
#include <string> // antet tipic C++
using namespace std;

int main ()
{
string str1 = "Hello";
string str2 = "World";
string str3;
int len ;

// copy str1 into str3

str3 = str1; // vlad: impossible in C (!)
std::cout << "str3 : " << str3 << endl;

// concatenates str1 and str2

str3 = str1 + str2;
cout << "str1 + str2 : " << str3 << endl;

// total length of str3 after concatenation

len = str3.size();
cout << "str3.size() : " << len << endl;

return 0;
}

Pointeri
- Pointerii sunt perfect compatibili C vs. C++
o Operatorii * și &
o Aritmetica pointerilor (v. și vectorii)
 o Pointerii NULL primesc o valoare dedicată: nullptr (începând cu standardul
C++11)
o Pointerii dubli == pot reține adresa din memoria a unei variabile pointer și
dubla de-referențiere îmi dă posibilitatea de a accesa locația variabilei
(valoarea reținută de către pointerul dublu) către care am avut pointer-ul
simplu
o Funcții cu argument pointer și valoare rezultată pointer
 A tenție! Nu se returnează adresa unei variabile locale!
Structuri
- Structurile, enumerările și uniunile se păstrează
o Diferența dintre structură și uniune
- cin, cout, cerr (disp std. eroare), clog (atașat cerr, doar că menține un buffer de
mesaje) - funcții de intrare-ieșire (iostream)

Spații de nume
- Conceptul rămâne (spații de nume == namespaces) dar se extinde și poate fi
configurat
o Rol: posibilitatea de a folosi nume comune pentru mai multe entități
o Definiție: într-o zonă de program, un nume poate fi folosit pentru a
identifica entități diferite, doar dacă acele entități fac parte din spații de
nume disjuncte!!!
o Entitățile care fac parte din spații de nume distincte (pre-definite C)

Nume de tipuri;
Nume de funcții;
m acro-definiții

C uvinte- cheie

Nume de variabile;
Nume de enumerări;
Nume de structuri și uniuni;
Selectori de câmpuri de structură sau
Nume de parametri în declarații de
uniune
Etichete goto;
funcții;

Exem plu: de ce au fost necesare spațiile de nume în codul următor?

#include <iostream>
using namespace std;

// first name space

namespace first_space
{
void func(){
cout << "Inside first_space" << endl;
}
}
// second name space
namespace second_space
{
void func(){
cout << "Inside second_space" << endl;
}
}

//using namespace first_space; //vlad: w/o this the compiler issues an error
int main ()
{

// This calls function from first name space.

func();

return 0;
}
© Vlad Grosu, 2016-2020