Curs 9.

Concepte avansate in C++

1. Templates (pag 113 - 119 tutorial_C++)

1.1. Template - functii

template <class identifier>

function_declaration;
sau
template <typename identifier>
function_declaration;

class sau typename - aceasi semnificatie la function template

template <class myType>

myType GetMax (myType a, myType b) {
return (a>b?a:b);
}

1.2 Apelare template de functie

function_name <type> (parameters);

int x,y;
GetMax <int> (x,y);

2. Template clase

template <class identifier>

class_declaration;

Exemplu:

template <class T>

class mypair {
T values [2];
public:
mypair (T first, T second)
{
values[0]=first; values[1]=second;
}
};

Definitie obiect din clasa template

mypair<int> myobject (115, 36);

mypair<double> myfloats (3.0, 2.18);

definirea unor membri in afara clasei: precedati de prefixul: template <...>

template <class T>

T mypair<T>::getmax ()

3. Specializarea template-urilor

- se modifica nu numai tipul parametrilor ci si implementarea

template <> class mycontainer <char> { ... };

template <> - declara un template specializat

<char> - declara specializatea

template <class T> class mycontainer { ... }; - generic

template <> class mycontainer <char> { ... }; - specializat

Trebuie definiti din nou toti membri (nu sint mosteniti de la template-ul generic)

4. Parametri obisnuiti (non-type) ai template-urilor

Un template poate avea si parametri obisnuiti (care nu sint inlocuiti ca si tip)

template <class T=char, int N=10> class mysequence {..};

class T - parametru al carui tip se modifica (e generic in template)

int N=10 - parametru non-type (initializat cu 10)

Definirea unui obiect:

mysequence<> myseq;

mysequence<char,10> myseq;

4. Namespaces (pag 120 - 122 tutorial_C++)

Namespace - concept care grupeaza entitati (clase, obiecte, functii) sub acelasi
nume

Cuvintul cheie "namespace"

namespace identifier
{
entities
}

Exemplu:

namespace myNamespace
{
int a, b;
}

Accesarea entitatilor din namespace:

myNamespace::a
myNamespace::b

Cuvintul cheie "using"

dupa utilizarea "using" nu mai e necesara folosirea operatorului :: pentru

accesarea entitatilor din namespace

using namespace std;

sau
namespace first
{
int x = 5;
int y = 10;
}
namespace second
{
double x = 3.1416;
double y = 2.7183;
}

using first::x;
using second::y;
cout << x << endl;
cout << y << endl;

sau

using namespace first;

cout << x << endl;

cout << y << endl;

5. Exceptii (pag 123 - 126 tutorial_C++)

Exceptiile reprezinta un concept care asigura o modalitatea de a raspunde la

situatii de eroare la executie (sau la orice situatie care nu reprezinta modul
normal de functionare)

Pentru a verifica daca apare o astfel de situatie (o exceptie) -> secventa de

instructiuni plasata intr-un bloc "try"
Tratarea exceptiei - bloc "catch"

try // verifica daca apare o exceptie

{}
catch // tratarea exceptiei (exception handler)
{}

intructiunea throw n; // genereaza o exceptie

n - este transmis ca parameytru in blocul catch

Se poate limita tipul parametrului n

float myfunction (char param) throw (tip); // n este de tipul tip (de exemplu
tip=int) -> float myfunction (char param) throw (int);

sau

int myfunction (int param) throw(); // nu sint permise exceptii

int myfunction (int param); // sint permise exceptii parametru de orice tip

Exceptii standard in C++

<exception> header in namespace std

#include <exception>
using namespace std;
class myexception: public exception
{
virtual const char* what() const throw() // membru virtual what - poate fi
supradefinit
{
return "My exception happened";
}
} myex; // myex este o clasa derivta din clasa exception

in main:

try
{
throw myex;
}
catch (exception& e) // parametru pentru catch este un pointer la o clasa myex
{
cout << e.what() << endl;
}

In mod uzual - exceptii -> pentru alocarea dinamica

#include <exception>
using namespace std;
int main () {
try
{
int* myarray= new int[1000];
}
catch (exception& e)
{
cout << "Standard exception: " << e.what()
<< endl;
}
return 0;
}

6. Casting (pag 127 - 133 tutorial_C++)

- Modificarea tipului variabilelor

Conversii implicite
Conversii explicite: (tip)nume_var

- dynamic_cast

numai pentru pointeri si referinte la obiecte

class CBase { }; // clasa de baza

class CDerived: public CBase { }; // clasa derivata
CBase b; CBase* pb;
CDerived d; CDerived* pd;
pb = dynamic_cast<CBase*>(&d);
// corect -> cast clasa derivata la clasa de baza
pd = dynamic_cast<CDerived*>(&b);
// eronat cast clasa de baza la clasa derivata
static_cast
numai pentru pointeri si referinte la obiecte

class CBase {};

class CDerived: public CBase {};
CBase * a = new CBase;
CDerived * b = static_cast<CDerived*>(a); // e corect !

reinterpret_cast

folosit pentru clas acre nu sint intr-o relatie de tip clasa de baza , clasa
derivata
functioneaza pentru orice clase
class A {};
class B {};
A * a = new A;
B * b = reinterpret_cast<B*>(a);

7. Directive de preprocesor (pag 133 - 137)

macrodefinitii -> #define, #undef

compilare condititionata -> #ifdef, #ifndef, #if, #endif, #else, #elif

afisare numar de linie in cod -> #line

afisare eroare -> #error

includerea de fisiere -> #include

Directiva #pragma -> diferite optiuni pentru compilare

Exemple: ex_c9, Ex_try_catch (POO_C++, pag 23-25)

8. Biblioteca standard C++ (STL C++)

https://www.cplusplus.com/reference/stl/

Containere secvențiale: tablouri , vectori, liste

Exemple: Sequence Containers (1_Vector, 2_List, 3_Arrays)

Vector:
https://en.cppreference.com/w/cpp/container/vector
(vector_template.pdf)

- este un class template:

template<

class T,
class Allocator = std::allocator<T>
> class vector;

- inserare / eliminare element - nu in timp constant

- inserare si eliminare ultimul element - in timp constant
- accesare random - timp constant

trebuie incluse:
<vector> - clasa vector
<cstdlib> - alocari dinamice

- T este tipul elementelor

- Allocator - metoda de alocare / eliberare dinamica a memoriei
- elementele sint stocate la rind
- pot fi accesate in secventa (prin iterator - index) -
- se pot utiliza pointeri pentru a indica un element
- spatiul de stocare este expandat sau contractat automat

Exemple de metode pentru clasa vector:

push_back - inserare element

pop_back - stergere ultimul element
size - dimensiunea vectorului
it - iteratori (iterator - obiect care indica un element din vector , se poate
incrementa si variaza intree niste limite date
begin, end - inceputul , sfirsitul vectorului
clear - stergere vector

at

std::vector<int> data = { 1, 2, 4, 5, 5, 6 };

// Set element 1
data.at(1) = 88;

front - primul element

std::vector<char> letters {'o', 'm', 'g', 'w', 't', 'f'};

std::cout << "The first character is '" << letters.front() << "'.\n";

back - ultimul element

std::cout << "The last character is '" << letters.back() << "'.\n";

empty
std::vector<int> numbers;
numbers.empty() - intoarce tru sau false

erase:

void print_container(const std::vector<int>& c)

{
for (int i : c) {
std::cout << i << " ";
}
std::cout << '\n';
}

int main( )
{
std::vector<int> c{0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
print_container(c);

c.erase(c.begin());
print_container(c);

c.erase(c.begin()+2, c.begin()+5);
print_container(c);
 // Erase all even numbers (C++11 and later)
for (std::vector<int>::iterator it = c.begin(); it != c.end(); ) {
if (*it % 2 == 0) {
it = c.erase(it);
} else {
++it;
}
}
print_container(c);
}

iesire:
0 1 2 3 4 5 6 7 8 9
1 2 3 4 5 6 7 8 9
1 2 6 7 8 9
1 7 9

resize - redimensionare vector

reserve - rezervare memorie
shink_to_fit - reducere la capacitatea strict necesara

Exemple - Sequence Containers/1_Vector/Vector.cpp

Liste
https://en.cppreference.com/w/cpp/container/list
(list_template.pdf)

Exemple:

clasa list - template

template<

class T,
class Allocator = std::allocator<T>
> class list;

- inserare si eliminare element - in timp constant

- implementare ca lista dublu inlantuita (vezi SDA)

Membri:

push_front - insereaza la inceput

push_back - insereaza la sfirsit
pop_front - extrage de la inceput
pop_back - extrage de la sfirsit
front - primul element
back - ultimul element
size - dimensiunea listei
resize - redimensiunare lista
remove - stergere element
unique- eliminare duplicate
reverse - inversare lista
sort - sortare lista
merge - adaugare lista la lista
iterator - iteratii

forward list - implementare ca liste simplu inlantuite (SDA)

list - implementare ca liste dublu inlantuite (SDA)

diferente in ceea ce priveste flexibilitatea si timpul de acces

Exemple - Sequence Containers/2_List/ForwardLists.cpp, Lists.cpp

Tablouri (array)

https://en.cppreference.com/w/cpp/container/array
(array_template.pdf)

template

template<

class T,
std::size_t N
> struct array;

- are lungime fixa

Metode

at - pozitionare pe un element dat

size - dimensiunea tabloului
front - primul element
back - ultimul element
iterator - iteratii

Exemple - Sequence Containers/3_Arrays/Arrays.cpp