L1-Recapitulare limbajul C/C++

Summary of C/C++ language

Clase, obiecte, membri, accesul la membri.

Obiective:
 Înţelegerea teoretică şi practică a noţiunilor de clasă, obiect, membru al unei clase, accesul la
membrii unei clase, constructori, destructori.
 Scrierea de programe simple, după modelul programării obiectuale, care exemplifică noţiunile
menţionate mai sus.
Rezumat:

Programarea orientată pe obiecte implică definirea tipurilor abstracte de date în vederea

definirii obiectelor, a mesajelor precum şi a mecanismului de moştenire. Noţiunile de bază ale OOP se
referă în principal la definirea claselor de obiecte, a moştenirii şi a polimorfismului.
Clasele C++ reprezintă tipuri noi de date, care conţin metode şi variabile, un fel de „matriţe”
ce sunt folosite pentru a defini metodele şi variabilele unui obiect anume, „turnat” după modelul clasei.
Procesul de creare al unui obiect se numeşte instanţiere caz în care pentru fiecare variabilă se
vor preciza nişte valori concrete (explicit sau implicit).
Metodele unei clase pot să fie definite în interiorul ei (metode inline) sau în afară, caz în care
este necesară indicarea clasei prin operatorul rezoluţie sau scop ( :: ).
Accesul la variabilele şi metodele membre ale unei clase se poate controla prin utilizarea
specificatorilor de vizibilitate: public, private, protected.
Funcţiile constructor sunt funcţii care sunt apelate în momentul instanţierii unor obiecte, ele
nu au specificat nici un fel de tip returnat, au numele identic cu cel al clasei din care fac parte. Rolul
contructorilor este de a iniţializa variabilele din acea clasă şi de a aloca spaţiu de memorie
corespunzător obiectului instanţiat şi a variabilelor folosite în cadrul clasei.
Destructorul clasei este o metodă care, analog cu constructorul, poate fi recunoscută prin
refaptul că are acelaşi nume cu clasa din care face parte, este precedat de caracterul ~ şi are rolul de a
elibera spaţiul de memorie alocat pentru obiectul instanţiat şi a variabilelor folosite în cadrul clasei.

Exemple:
//1. Implementarea clasei Rectangle pentru efectuarea
//unor operatii elementare cu forme geometrice dreptunghiulare

#include <iostream>
using namespace std;
// clasa Rectangle
class Rectangle {
// membri private
int height;
int width;
public:
// membri publici
Rectangle(int length=10, int width=10); // constructor cu val. implicite
int get_area(void);
void set_values(int, int);
~Rectangle(void); // destructor
};

Rectangle::Rectangle(int h, int w) // constuctor

{
if((h==10) && (w==10))
cout << "\nApel constructor (valori implicite)...";
else
cout << "\nApel constructor (valori oarecare)...";
height = h;
 width = w;
}
Rectangle::~Rectangle(void) // destructor
{
cout << "\nApel destructor...";
height = 0;
width = 0;
}

int Rectangle::get_area(void)
{
return height * width;
}

void Rectangle::set_values(int init_height, int init_width)

{
height = init_height;
width = init_width;
}

void main()
{
int index;
// obiecte de tipul Rectangle
Rectangle rect, square;//inst.cu val implicite
cout << "\nObiecte(acces cu operatorul .): \n";
cout << "\tValori implicite: \n";
cout << "\t\tAria dreptunghilui: " << rect.get_area() << "\n";
cout << "\t\tAria patratului: " << square.get_area() << "\n\n";
cout << "\tValori oarecare: \n";
rect.set_values(12, 10);
cout << "\t\tAria dreptunghilui: " << rect.get_area() << "\n";
square.set_values(8, 8);
cout << "\t\tAria patratului: " << square.get_area();
cout << "\n...................................\n\n";

// pointer la tipul Rectangle

Rectangle *point;
cout << "\nPointeri la obiecte (acces cu operatorul ->):";
point = new Rectangle;//inst. cu val. implicite
cout << "\n\tValori implicite: \n";
cout << "\t\tAria dreptunghilui:" << point->get_area() << "\n";
cout << "\tValori oarecare: \n";
point->set_values(12, 12);
cout << "\t\tAria dreptunghilui: " << point->get_area() << "\n";
delete point;
cout << "\n...................................\n\n";
}//main
//******************************************************************************
//2. Implementarea unei clase numita Stiva pentru simularea lucrului cu stiva
class Stiva
{
//membri privati
private:
int Dim;
char *Stack;
int Next;
//membri publici
public:
Stiva();
 Stiva(int);
~Stiva();

int Push(char c);

int Pop(char &c);
int IsEmpty(void);
int IsFull(void);
};

// constructori
Stiva :: Stiva()
{
Next = -1;
Dim = 256;
Stack = new char [Dim];
}

Stiva :: Stiva(int dim_i)

{
Next = -1;
Dim = dim_i;
Stack = new char [Dim];
}

// destructor
Stiva :: ~Stiva()
{
delete [] Stack;
}

// test stiva goala

int Stiva :: IsEmpty(void)
{
if (Next < 0)
return 1;
else
return 0;
}
// test stiva plina
int Stiva::IsFull(void)
{
if(Next >= Dim)
return 1;
else
return 0;
}
// introducere in stiva
int Stiva::Push(char c)
{
if(IsFull())
return 0;
*Stack++ = c;
Next++;
return 1;
}
// extragere din stiva
int Stiva::Pop(char &c)
{
if(IsEmpty())
return 0;
 c = *(--Stack);
Next--;
return 0;
}

// program de test
#include <iostream>
#include <string.h>
using namespace std;

void main(void)
{
int i;
char buf[64];
strcpy(buf, "Bafta in sesiune !");

Stiva Mesaj;

for(i=0; i<strlen(buf); i++)

Mesaj.Push(buf[i]);

i=0;
while(!Mesaj.IsEmpty())
Mesaj.Pop(buf[i++]);
cout << endl << buf << endl;

}//main

Teme:
1. Să se scrie o aplicaţie C/C++ care foloseşte o structură de date cu numele Cerc care conţine
raza ca şi o variabilă de tip întreg. Într-un program C/C++, declaraţi două variabile c1, c2 de
tip Cerc şi calculaţi aria şi circumferinţa lor pentru valori ale razei introduse de la tastatură cu
două metode definite. Aceleaşi cerinţe vor fi implementate într-o aplicaţie folosind o clasă
numită Cerc cu atributul raza privat, clasă ce va conţine pe lângă metodele de calcul ale ariei
şi perimetrului un constructor explicit cu parametru, un destructor şi o metodă de afişare raza.
Extindeţi aplicaţia astfel încât să definiţi mai multe obiecte de tip Cerc la care să accesaţi
metodele specifice folosind obiectele instanţiate, pointeri la obiecte, referinţe la obiecte.
Introduceţi o metodă de tip accesor, ReadRaza() care permite accesul la data privată raza.
2. Să se modifice exemplul al doilea aşa încât să îndeplinească următoarele cerinţe:
a. să se declare obiecte ce utilizează constructorul cu parametri
b. modificaţi programul astfel încât să se facă atribuiri de obiecte
c. să se depună pe stivă numere aleatoare în domeniul (0..1000)
3. Să se definească o clasă numită String (într-un fişier numit strClass.h) care să fie compusă din
funcţiile specifice care efectuează următoarele operaţii pe şiruri de caractere:
- determină lungimea şirului primit pe intrare;
- determină ultima poziţie de apariţie a unui anumit caracter din şirul de intrare;
- returnează şirul primit pe intrare, scris cu caractere majuscule;
- returnează şirul primit pe intrare, scris cu caractere minuscule;
- returnează numărul de apariţii ale unui anumit caracter din şirul primit;
4. Să se scrie programul care citeşte de la tastatură un şir de maxim 10 caractere şi care, pe baza
clasei implementate anterior, efectuează asupra şirului de intrare operaţiile definite în cadrul
clasei.
5. Să se scrie programul care implementează clasa Suma şi care, în cadrul funcţiei main, declară
un obiect de tipul clasei şi apoi un pointer la acesta, prin intermediul cărora se va afişa pe
ecran rezultatul adunării a două numere preluate de la tastatură. Încercaţi implementarea
funcţiei suma în cadrul clasei şi în exteriorul acesteia.
6. Să se definească o clasă care implementează funcţiile:
- int plus(int x, int y), care returnează suma valorilor primite la apelul metodei;
- int minus(int x, int y), care returnează suma valorilor primite la apelul metodei;
- int inmultit(int x, int y), care returnează suma valorilor primite la apelul metodei;
 - int impărţit(int x, int y), care returnează suma valorilor primite la apelul metodei;
şi apoi să se scrie aplicaţia care utilizează această clasă.
Observaţie: În cazul împărţirii, trebuie verificată validitatea operaţiei (împărţitor diferit de
zero). În cazul în care operaţia este imposibilă, trebuie afişat un mesaj de eroare.
7. Să se creeze o clasă care să modeleze numerele complexe. Scrieţi un program care utilizează
această clasă.
Homework:
1. Write a C/C++ application that uses a data structure named Circle. The structure has an integer
variable that represents the circle’s radius. In the main program that uses the Circle structure, declare 2
Circle variables (c1 and c2) and calculate the area and the perimeter (using 2 methods) for 2 circles
with the value of the radius read from the keyboard.
Perform the same operations using a class called Circle (the radius is a private member of the
class). The class contains, besides those 2 methods defined in the first application, an explicit
constructor with 1 parameter, a destructor and another method that displays the circle’s radius.
Extend the application by defining several Circle objects, pointers to the declared objects and
refferences to those objects.
2. Modify the 2-nd example in order for the program to perform the following tasks:
a. declare some objects that use the constructor with parameters;
b. modify the program by introducing some object attributions;
c. store on the stack random numbers between 0 and 1000.
3. Declare a class called String and store it in a file named strClass.h. The functions in the class
perform the following tasks:
a. determine the length of the array of characters received as parameter;
b. determine the index of the last occurence of a certain character in the array;
c. return the array of characters received as parameter, all letters being transformed into capital
letters.
d. return the number of occurences of a certain character;
4. Write a program that reads from the keyboard an array of maximum 10 characters and performs all
the operations implemented in the class defined at problem 3.
5. Write a program that implements a class called Sum. In function main, declare a Sum object and a
pointer to this object. Use the defined variables for displaying the sum of 2 numbers read from the
keyboard.
6. Define a class that implements the following methods:
- int plus(int x, int y), which returns the sum of x and y;
- int minus(int x, int y), which returns the difference between x and y;
- int inmultit(int x, int y), which returns the result of x multiplied by y;
- int impărţit(int x, int y), which returns the quotient of x and y;
Write the application that uses this class.
Obs: prevent the division of a number by 0. If this situation occurs, display an error message.
7. Define a class that manages complex numbers. Write the program that uses this class.

Constructori. Destructori. Tablouri de obiecte.

Obiective:
 Înţelegerea teoretică şi practică a noţiunilor constructor, destructor, tablouri de obiecte .
 Scrierea de programe simple, după modelul programării obiectuale, care exemplifică noţiunile
menţionate mai sus.
Rezumat:
Constructorii pot fi:
- impliciţi
- expliciţi
o vizi: fară nici un argument
o cu parametrii: iniţializează anumite variabile din clasă şi/sau efectuează anumite
operaţii conform variabilelor primite ca argumente.
Un tip special de constructor este constructorul de copiere, al cărui menire este de a crea copia
unui obiect. Constructorii de copiere sunt obligatorii doar în cazul în care clasa respectivă se definesc
pointeri ce necesita alocare dinamică pentru a se rezerva spaţiu.
 Destructorul :
- poate fi definit: dacă se doreşte efectuarea anumitor operaţii în momentul distrugerii
obiectului
- poate să lipsească: se apelează un destructor implicit de către compilator.
Pointerul this pointează spre membrii instanţei curente a clasei (este apelabil doar din
interiorul clasei). Este util când în interiorul unei funcţii dintr-o clasă este necesar să facem distincţie
între variabile ce aparţin la obiecte diferite, pointerul this indicând întotdeauna obiectul curent.
Pentru a crea tablouri de obiecte avem nevoie cel puţin de un constructor explicit vid. Dacă se
foloseşte un constructor cu parametrii, fiecare obiect din tablou poate fi iniţializat indicând o listă de
iniţializare.

Exemple:
//1. Implementarea clasei Rectangle pentru efectuarea
//unor operatii elementare cu forme geometrice dreptunghiulare

#include <iostream>
using namespace std;
// clasa Rectangle
class Rectangle {
// membri private
int height;
int width;
public:
// membri publici
Rectangle(int length=10, int width=10); // constructor cu val. implicite
int get_area(void);
void set_values(int, int);
~Rectangle(void); // destructor
};

Rectangle::Rectangle(int h, int w) // constuctor

{
if((h==10) && (w==10))
cout << "\nApel constructor (valori implicite)...";
else
cout << "\nApel constructor (valori oarecare)...";
height = h;
width = w;
}
Rectangle::~Rectangle(void) // destructor
{
cout << "\nApel destructor...";
height = 0;
width = 0;
}

int Rectangle::get_area(void)
{
return height * width;
}

void Rectangle::set_values(int init_height, int init_width)

{
height = init_height;
width = init_width;
}

void main()
{
int index;
// tablou de obiecte
Rectangle group1[4]={
Rectangle(10,10),
Rectangle(20,10),
Rectangle(30,10),
Rectangle(40,10)};

cout << "\n\nTablou de obiecte initializat la declarare\n";

for (index = 0 ; index < 4 ; index++)
cout << "\tAria dreptunghiului: " << group1[index].get_area() << "\n";
cout << "\n...................................\n\n";

// tablou de obiecte
Rectangle group2[4];
cout << "\nTablou de obiecte initializat cu metoda set_values()\n";
for (index = 1 ; index < 4 ; index++)
group2[index].set_values(index + 10, 10);
for (index = 0 ; index < 4 ; index++)
cout << "\tAria dreptunghiului: " << group2[index].get_area() << "\n";
cout << "\n...................................\n\n";
// tablou dinamic
Rectangle *group3 = new Rectangle[4];
cout << "\nTablou dinamic de obiecte initializat cu metoda set_values()\n";
for (index = 0 ; index < 4 ; index++)
group3[index].set_values(index + 10, 10);
for (index = 0 ; index < 4 ; index++)
cout << "\tAria dreptunghiului: " << group3[index].get_area() << "\n";
delete []group3;
cout << "\n...................................\n\n";
// tablou dinamic
Rectangle *group4 = new Rectangle[4];
group4[0]=Rectangle(5,10);
group4[1]=Rectangle(15,20);
group4[2]=Rectangle(25,30);
group4[3]=Rectangle(35,40);
cout << "\nTablou de obiecte initializat prin constructor\n";
for (index = 0 ; index < 4 ; index++)
cout << "\tAria dreptunghiului: " << group4[index].get_area() << "\n";
delete []group4;
cout << "\n...................................\n\n";
}//main
//******************************************************************************
//2. Implementarea unei clase numita Stiva pentru simularea lucrului cu stiva
class Stiva
{
//membri privati
private:
int Dim;
char *Stack;
int Next;
//membri publici
public:
Stiva();
Stiva(int);
Stiva(Stiva &);
~Stiva();

int Push(char c);

int Pop(char &c);
int IsEmpty(void);
 int IsFull(void);
};

// constructori
Stiva :: Stiva()
{
Next = -1;
Dim = 256;
Stack = new char [Dim];
}

Stiva :: Stiva(int dim_i)

{
Next = -1;
Dim = dim_i;
Stack = new char [Dim];
}
//constructor de copiere
Stiva :: Stiva(Stiva &inStack)
{
Next = inStack.Next;
Dim = inStack.Dim;
Stack = new char[Dim];
for(int i=0; i<Next;i++)
Stack[i] = inStack.Stack[i];
}

// destructor
Stiva :: ~Stiva()
{
delete [] Stack;
}

// test stiva goala

int Stiva :: IsEmpty(void)
{
if (Next < 0)
return 1;
else
return 0;
}
// test stiva plina
int Stiva::IsFull(void)
{
if(Next >= Dim)
return 1;
else
return 0;
}
// introducere in stiva
int Stiva::Push(char c)
{
if(IsFull())
return 0;
*Stack++ = c;
Next++;
return 1;
}
// extragere din stiva
int Stiva::Pop(char &c)
{
if(IsEmpty())
return 0;
c = *(--Stack);
Next--;
return 0;
}
// program de test
#include <iostream>
#include <string.h>
using namespace std;

void main(void)
{
int i;
char buf[64];
strcpy(buf, "Bafta in sesiune !");

Stiva Mesaj;

for(i=0; i<strlen(buf); i++)

Mesaj.Push(buf[i]);

i=0;
while(!Mesaj.IsEmpty())
Mesaj.Pop(buf[i++]);
cout << endl << buf << endl;

// constructor de copiere
Stiva Mesaj1(Mesaj);
i=0;
while(!Mesaj1.IsEmpty())
Mesaj1.Pop(buf[i++]);
cout << endl << buf << endl;
}//main
//******************************************************************************
// 3. Exemplu de utilizare a constructorului de copiere pentru un punct caruia i se asociaza un text
#include <iostream>
using namespace std;
#include <string.h>

#include <stdio.h>

class CPunctText
{
public:
//constructor standard
CPunctText();
//constructor de initializare
CPunctText(int ix, int iy, char *sText="Punct");
//constructor de copiere
CPunctText(CPunctText &pct);
//destructor:
~CPunctText();

public:
void Afis()
{
cout << "\nObiectul are x= " <<x;
cout << "\nObiectul are y= " <<y;
 cout << "\nObiectul are sirul = " <<sNume;

}//afis
private:
int x;
int y;
int lungime_sir;
char *sNume;
};

CPunctText::CPunctText()
{
cout << "\n constructor standard";
lungime_sir = 20;
sNume=new char[lungime_sir];
}

CPunctText::CPunctText(int ix, int iy, char *sText)

{
cout << "\n constructor de initializare";
lungime_sir = strlen(sText)+1;
sNume=new char[lungime_sir];
x=ix;
y=iy;

strcpy(sNume, sText);
}

CPunctText::CPunctText(CPunctText &pct)
{
cout << "\n constructor de copiere";
sNume=new char[pct.lungime_sir+1];
x=pct.x;
y=pct.y;
lungime_sir = pct.lungime_sir+1;
strcpy(sNume,pct.sNume);
}

CPunctText::~CPunctText()
{
cout << "\n destructor";
delete sNume;
}

void main(void)
{
CPunctText cpt1(1,2,"Punct1");//apel constructor standard

CPunctText cpt2(cpt1); //apel constructor de copiere

CPunctText cpt3=cpt2; //apel constructor de copiere

CPunctText cpt4(4,5); //apel constructor de initializare

cpt3.Afis();
}

Teme:
1. Modificaţi exemplul 3 astfel încât să permită adunarea a două astfel de puncte. Numele noului
punct va fi rezultat prin concatenarea numelor celor două puncte.
 2.Să se scrie o aplicaţie C/C++ în care modeleze obiectual un şir de numere reale. Creaţi două
instanţe ale clasei create având aceeaşi lungime n şi notaţi rezultatul adunării element cu
element într-un al treilea şir.
3. Să se scrie o aplicaţie înare se modelează clasa Student cu nume, prenume şi notele din
sesiunea din iarnă. Să se afişeze numele primilor trei studenţi din grupă în ordinea mediilor.
4. Să se scrie o aplicaţie C/C++ în care se citeşte de la tastatură un punct prin coordonatele x,y,z.
Să se scrie o metodă prin care să se facă translaţia punctului cu o anumită distanţă pe fiecare
dintre cele trei axe. Să se verifice dacă dreapta care uneşte primul punct şi cel rezultat în urma
translaţiei trec printr-un al treilea punct dat de la consolă.
Homework:
1. Modify example 3 in order to allow the addition of two CPunctText points. The name of the
new point will be created from the names of the compounding points.
2. Write a C/C++ application that models in OOP a real numbers string. Instantiate two objects
of this class with the same length n and store in a third one the results of adding each of the
two real number strings’ elements.
3. Model in OOP a class named Student containing name, surname and the marks from the
winter session exams. Display the name of the first three students in the group.
4. Write a C/C++ application that reads a point from the keyboard by giving the x,y,z
coordinates . Write a method that moves the point with a given distance on each of the three
axes. Verify if the line between the first and the second position of the point crosses a third
given point.