1. 1.
/*Testa?i exemplele din laborator introducand clasele in fisiere header
distincte, care vor fi incluse in programul principal.
Problema 1
*/
//Modalitatea de definire si utilizare a metodelor virtuale
//fisierul antet automobil.h
class Automobil : public Vehicul
{
int incarcatura_pasageri;
public:
void mesaj(void)
{
cout << "Mesaj din clasa Automobiln";
}
};
//fisierul antet barca.h
class Barca : public Vehicul
{
int incarcatura_pasageri;
public:
int pasegeri(void)
{
return incarcatura_pasageri;
}
void mesaj(void)
{
cout << "Mesaj din clasa Barcan";
}
};
//fisierul antet camion.h
class Camion : public Vehicul
{
int incarcatura_pasageri;
float incarcatura_utila;
public:
int pasageri(void)
{
return incarcatura_pasageri;
}
};
//fisierul antet vehicul.h
class Vehicul
{
int roti;
float greutate;
public:
virtual void mesaj(void)
{
cout << "Mesaj din clasa Vehiculn";
}
2. };
#include<conio.h>
#include<iostream>
using namespace std;
#include "automobil.h"
#include "barca.h"
#include "camion.h"
#include "vehicul.h"
void main(void)
{
// apel direct, prin intermediul unor obiecte specifice
Vehicul monocicleta;
Automobil ford;
Camion semi;
Barca barca_de_pescuit;
monocicleta.mesaj();
ford.mesaj();
semi.mesaj();
barca_de_pescuit.mesaj();
// apel prin intermediul unui pointer specific
Vehicul *pmonocicleta;
Automobil *pford;
Camion *psemi;
Barca *pbarca_de_pescuit;
cout << "n";
pmonocicleta = &monocicleta;
pmonocicleta->mesaj();
pford = &ford;
pford->mesaj();
psemi = ;
psemi->mesaj();
pbarca_de_pescuit = &barca_de_pescuit;
pbarca_de_pescuit->mesaj();
// apel prin intermediul unui pointer catre un obiect al clasei de baza
cout << "n";
pmonocicleta = &monocicleta;
pmonocicleta->mesaj();
pmonocicleta = &ford;
pmonocicleta->mesaj();
pmonocicleta = ;
pmonocicleta->mesaj();
pmonocicleta = &barca_de_pescuit;
pmonocicleta->mesaj();
getch();
}
Problema 2
/*Exemplu cu clase abstracte si functii virtuale pure*/
//fisier Shape.h
class Shape {
protected:
3. int xorig;
int yorig;
Color co;
public:
Shape(int x, int y, Color c) : xorig(x), yorig(y), co(c) {}
virtual ~Shape() {} // destructor virtual
virtual void draw() = 0; // functie virtuala pura
};
//fisier Line.h
class Line : public Shape {
int xdest;
int ydest;
public:
Line(int x, int y, Color c, int xd, int yd) :xdest(xd), ydest(yd),
Shape(x, y, c) {}
~Line() {cout << "~Linien";} // destructor virtual
void draw() // functie virtuala
{
cout << "Linie" << "(";
cout << xorig << ", " << yorig << ", " << int(co);
cout << ", " << xdest << ", " << ydest;
cout << ")n";
}
};
//fisier Circle.h
class Circle : public Shape {
int raza;
public:
Circle(int x, int y, Color c, int r) : raza(r), Shape(x, y, c) {}
~Circle() {cout << "~Cercn";} // destructor virtual
void draw() // functie virtuala
{
cout << "Cerc" << "(";
cout << xorig << ", " << yorig << ", " << int(co);
cout << ", " << raza;
cout << ")n";
}
};
//fisier Text.h
class Text : public Shape {
char* str;
public:
Text(int x, int y, Color c, const char* s) : Shape(x, y, c)
{
str = new char[strlen(s) + 1];
strcpy(str, s);
}
~Text() {delete [] str; cout << "~Textn";} // destructor virtual
void draw() // functie virtuala
{
cout << "Text" << "(";
cout << xorig << ", " << yorig << ", " << int(co);
cout << ", " << str;
cout << ")n";
}
};
#include<iostream>
using namespace std;
#include<string.h>
4. #include "Shape.h"
#include "Line.h"
#include "Circle.h"
#include "Text.h"
enum Color {Co_red, Co_green, Co_blue};
void main(void)
{
const int N = 5;
int i;
Shape* sptrs[N];
sptrs[0] = new Line(1, 1, Co_blue, 4, 5);
sptrs[1] = new Line(3, 2, Co_red, 9, 75);
sptrs[2] = new Circle(5, 5, Co_green, 3);
sptrs[3] = new Text(7, 4, Co_blue, "Salut echipa de lucru ...&...!");
sptrs[4] = new Circle(3, 3, Co_red, 10);
for (i = 0; i < N; i++)
sptrs[i]->draw();
for (i = 0; i < N; i++)
delete sptrs[i];
cin.get();
}
Problema 3
/*Clasa de baza Baza este mostenita virtual atat de Derivata1 cat si de Derivata
2*/
//fisier Baza.h
class Baza {
public:
Baza(){
cout<<"Apel la constructorul clasei de bazan";
}
}; // clasa de baza
//fisier Derivata1.h
class Derivata1 : virtual public Baza {
public:
Derivata1(){
cout<<"Apel la constructorul clasei Derivata1n";
}
};
//fisier Derivata2.h
class Derivata2 : virtual public Baza {
public:
Derivata2(){
cout<<"Apel la constructorul clasei Derivata2n";
}
};
//fisier Derivata1si2.h
class Derivata1si2 : public Derivata1, public Derivata2 {
public:
Derivata1si2(){
cout<<"Apel la constructorul clasei Derivata1si2n";
}
};
#include<iostream>
using namespace std;
#include "Derivata1.h"
5. #include "Derivata2.h"
#include "Derivata1si2.h"
void main(void){
Derivata1si2 ob;
cin.get();
}
2.
/*La primul exemplu extindeþi clasa de bazã cu alte funcþii virtuale, redefinite
în clasele derivate, cum ar fi
metode get ºi set pentru greutatea vehicolului (variabila greutate).
*/
//fisierul antet vehicul.h
class Vehicul {
int roti;
float greutate;
public:
virtual void mesaj(void)
{
cout << "Mesaj din clasa Vehiculn";
}
virtual void set_greutate(float g)
{
greutate=g;
}
virtual float get_greutate()
{
return greutate;
}
};
//fisierul antet camion.h
class Camion : public Vehicul {
int incarcatura_pasageri;
float incarcatura_utila;
public:
int pasageri(void)
{
return incarcatura_pasageri;
}
void mesaj()
{
cout<<"Mesaj din clasa camion";
}
virtual float get_greutate()
{
cout<<"Greutatea camionului:";
return vehicul::get_greutate();
}
virtual void set_greutate(float g)
{
vehicul::set_greutate(g);
cout<<"S-a setat greutatea camionului la valoarea:
"<<vehicul::set_greutate()<<endl;
}
6. };
//fisierul antet barca.h
class Barca : public Vehicul {
int incarcatura_pasageri;
public:
int pasegeri(void)
{
return incarcatura_pasageri;
}
void mesaj(void)
{
cout << "Mesaj din clasa Barcan";
}
virtual float get_greutate()
{
cout<<"Greutatea barcii este:";
return vehicul::get_greutate();
}
virtual void set_greutate(float g)
{
vehicul::set_greutate(g);
cout<<"S-a setat greutatea barcii la valoarea:
"<<vehicul::get_greutate()<<endl;
}
};
//fisierul antet automobil.h
class Automobil : public Vehicul {
int incarcatura_pasageri;
public:
void mesaj(void)
{
cout << "Mesaj din clasa Automobiln";
}
virtual float get_greutate()
{
cout<<"Greutatea automobilului este:";
return vehicul::get_greutate();
}
virtual void set_greutate(float g)
{
vehicul::set_greutate(g);
cout<<"S-a setat greutatea automobilului la valoarea:
"<<vehicul::get_greutate()<<endl;
}
};
#include<iostream>
using namespace std;
#include "vehicul.h"
#include "camion.h"
#include "barca.h"
#include "automobil.h"
void main(void)
{
// apel direct, prin intermediul unor obiecte specifice
Vehicul monocicleta;
Automobil ford;
Camion semi;
Barca barca_de_pescuit;
cout<<"Apel prin obiecte specifice:n";
7. monocicleta.mesaj();
ford.mesaj();
semi.mesaj();
barca_de_pescuit.mesaj();
// apel prin intermediul unui pointer specific
Vehicul *pmonocicleta;
Automobil *pford;
Camion *psemi;
Barca *pbarca_de_pescuit;
cout << "Apel prin ptr specifici:n";
pmonocicleta = &monocicleta;
pmonocicleta->mesaj();
pford = &ford;
pford->mesaj();
psemi = ;
psemi->mesaj();
pbarca_de_pescuit = &barca_de_pescuit;
pbarca_de_pescuit->mesaj();
// apel prin intermediul unui pointer catre un obiect al clasei de baza
cout << "Apel prin ptr la clasa de baza:n";
pmonocicleta = &monocicleta;
pmonocicleta->mesaj();
pmonocicleta->set_greutate(400);
cout<<pmonocicleta->get_greutate()<<endl;
cout<<endl;
pmonocicleta = &ford;
pmonocicleta->mesaj();
pmonocicleta->set_greutate(270);
cout<<pmonocicleta->get_greutate()<<endl;
cout<<endl;
pmonocicleta = ;
pmonocicleta->mesaj();
pmonocicleta->set_greutate(350);
cout<<pmonocicleta->get_greutate()<<endl;
cout<<endl;
pmonocicleta = &barca_de_pescuit;
pmonocicleta->mesaj();
pmonocicleta->set_greutate(300);
cout<<pmonocicleta->get_greutate()<<endl;
cout<<endl;
cin.get();
}
3.
/*Sã se scrie un program C++ în care se defineºte o clasã Militar cu o metodã
publicã virtualã sunt_militar() care indicã
apartenenþa la armatã. Derivaþi clasa Militar pentru a crea clasa Soldat ºi
clasa Ofiter. Derivaþi mai departe clasa Ofiter
pentru a obtine clasele Locotenent, Colonel, Capitan, General. Redefiniti
metoda sunt_militar() pentru a indica gradul militar
pentru fiecare clasa specifica. Instantiati fiecare clasa Soldat,
Locotenent,...,General, si apelati metoda sunt_militar().
*/
//fisier Militar.h
class Militar
{
char nume[20];
int varsta;
8. public:
virtual void mesaj ()
{
cout<<"nMesaj din clasa Militar";
}
void set_values(char *n, int v)
{
strcpy(nume,n);
varsta=v;
}
virtual void sunt_militar()
{
cout<<nume<<" lucteaza in cadrul armatei";
}
};
//fisier Soldat.h-clasa derivata din militar
class Soldat:public Militar
{
public:
void mesaj ()
{
cout<<"Mesaj din clasa Soldat;"
}
virtual void sunt_militar()
{
cout<<"Gradul:Soldatn";
}
};
//fisier Ofiter.h - derivata din clasa Militar
class Ofiter:public Militar
{
public:
void mesaj ()
{
cout<<"Mesaj din clasa Ofiter;"
}
virtual void sunt_militar()
{
cout<<"Gradul:Ofitern";
}
};
//fisier Colonel.h -derivata din clasa Ofiter
class Colonel:public Ofiter
{
public:
void mesaj ()
{
cout<<"Mesaj din clasa Colonel";
}
virtual void sunt_militar()
{
cout<<"Gradul:Coloneln";
}
};
//fisier Capitan.h -derivata din clasa Ofiter
class Capitan:public Ofiter
{
public:
void mesaj ()
{
9. cout<<"Mesaj din clasa Capitan";
}
virtual void sunt_militar()
{
cout<<"Gradul:Capitann";
}
};
//fisier General.h -derivata din clasa Ofiter
class General:public Ofiter
{
public:
void mesaj ()
{
cout<<"Mesaj din clasa General";
}
virtual void sunt_militar()
{
cout<<"Gradul:Generaln";
}
};
//fisier Capitan.h -derivata din clasa Ofiter
class Locotenent:public Ofiter
{
public:
void mesaj ()
{
cout<<"Mesaj din clasa Locotenent";
}
virtual char* sunt_militar()
{
return ("Locotenentn");
}
};
#include<iostream>
using namespace std;
#include "Militar.h"
#include "Soldat.h"
#include "Ofiter.h"
#include "Locotenent.h"
#include "Capitan.h"
#include "General.h"
#include<string.h>
void main ()
{
char n[20];
int v;
cout<<"Dati numele:"; cin>>n;
cout<<"Dati varsta:"; cin>>v;
Militar mili;
mili.set_values(n,v);
Soldat sol;
Ofiter of;
Locotenent loc;
Colonel col;
Capitan cap;
General gen;
cout<<"nApel metoda prin obiecte specifice n";
mili.sunt_militar();
sol.sunt_militar();
10. of.sunt_militar();
loc.sunt_militar();
col.sunt_militar();
cap.sunt_militar();
gen.sunt_militar();
cout<<"nApel metoda prin ptr la clasa Militar respectiv Ofiter";
//declaram un ptr catre Militar care va pointa pe obiecte din Soldat si
ofiter
Militar*pmili=/
pmili->sunt_militar();
pmili=&of;
pmili->sunt_militar();
//declaram un ptr catreOfiter care va pointa pe ob din clasele Loc, Col,
Cap, gen
Ofiter *pof=&loc;
pof->sunt_militar();
pof=&col;
pof->sunt_militar();
pof=∩
pof->sunt_militar();
pof=&gen;
pof->sunt_militar();
}
4.
/*Declarati o clasa Animal, care va contine o metoda pur virtuala, respira() si
doua metode virtuale manaca() si
doarme(). Derivati in mod public o clasa Caine si alta Peste, care vor defini
metoda pur virtuala, iar clasa Caine
va redefini metoda mananca(), iar Peste metoda doarme(). Instantiati obiecte din
cele doua clase si apelati metodele specifice.
Definiti apoi un tablou de tip Animal, care va contine obiecte din clasele
derivate, daca e posibil.
Daca nu, gasiti o solutie adecvata.
*/
class Animal
{
public:
virtual void mesaj()
{
cout<<"Mesaj din clasa Animal";
}
virtual void respira()=0;
virtual void mananca()
{
cout<<"Ce mananca de obicei?";
}
virtual void doarme ()
{
cout<<"Cat doarme?";
}
};
class Caine: public Animal
{
public:
void mesaj()
{
11. cout<<"Mesaj din clasa Caine";
}
void respira()
{
cout<<"Respira";
}
void mananca()
{
cout<<"Mananca orice ii dau";
}
};
class Peste:Public Animal
{
public:
void mesaj()
{
cout<<"Mesaj din clasa Peste";
}
void respira ()
{
cout<<"Respira prin branhii";
}
void doarme()
{
cout<<"Nu doarme deloc";
}
};
#include<iostream>
using namespace std;
#include"Animal.h"
#include"Caine.h"
#include"Peste.h"
void main ()
{
const int N=2;
Caine azor;
azor.mesaj();
azor.respira();
azor.mananca();
cout<<endl;
Peste pestisor;
pestisor.mesaj();
pestisor.respira();
pestirsor.doarme();
cout<<endl;
Animal *tab[n];
tab[0]=new Caine;
tab[1]=new Peste;
for (int i=0;i<N;i++)
{
cout<<endl;
tab[i]->mesaj();
tab[i]->doarme();
tab[i]->mananca();
tab[i]->respira();
}
for (int i=0;i<N;i++)
{
12. delete tab[i];
}
}
5.
/*Definiti o clasa abstracta care contine 3 declaratii de metode pentru
concatenarea, intreteserea a doua siruri de caractere
si inversarea unui sir de caractere primit ca parametru. O subclasa
implementeaza corpurile metodelor declarate in clasa de baza.
Instantiati clasa derivata si afisati rezultatele aplicarii operatiilor
implementate in clasa asupra unor siruri de caractere citite
de la tastatura. Examinati eroarea data de incercarea de a instantia clasa de
baza.
*/
#include<string.h>
#include<iostream>
using namespace std;
class Sir
{
public:
virtual char* concatenare(char *s1, char*s2)=0;
virtual char* intresetare(char*s1, char*s2)=0;
virtual char* inversare(char* s)=0;
};
class Sir_derivata
{
public:
char* concatenare(char *s1, char* s2)
{
return strcat(s1,s2);
}
char *intresetare(char*s1, char*s2)
{
int l1=strlen(s1), l2=strlen(s2);
int min=(l1<l2?l1:l2);
int k=0;
char *r=new char[l1+l2];
for(int i=0;i<min;i++)
{
r[k++]=s1[i];
r[k++]=s2[i];
}
if(l1<l2)
for(int i=min;i<l2;i++)
r[k++]=s2[i];
else
for(int i=min;i<l1;i++)
r[k++]=s1[i];
r[k]='0';
return r;
}
char*inversare(char*s)
{
/*int l=strlen(s);
char *s1=NULL;
s1=new char[l];
13. for(int i=0;i<l;i++)
{
s1[i]=s[l-i-1];
}
s1[l]='0';
return s1;*/
char *s1=NULL;
s1=strrev(s);
return s1;
}
};
void main ()
{
char s1[50], s2[50], s3[50];
Sir_derivata ob;
cout<<"Dati s1:"; cin>>s1;
cout<<"Dati s2:"; cin>>s2;
cout<<"Dati s3:"; cin>>s3;
cout<<"nSirul obtinut prin intresetarea primelor
doua:"<<ob.intresetare(s1,s2);
cout<<"nSirul obtinut prin concatenarea primelor
doua:"<<ob.concatenare(s1,s2);
cout<<"nSirul 3 inversat:"<<ob.inversare(s3);
}
6.
/*Definiti o clasa numita Record care stocheaza informatiile aferente unei
melodii (artist, titlu, durata). O clasa abstracta (Playlist)
contine ca variabila privata un pointer spre un sir de obiecte de tip
inregistrare. In constructor se aloca memorie pentru un numar de
inregistrari definit de utilizator. Clasa contine metode accesor si mutator
pentru datele componente ale unei inregistrari si o metoda
abstracta cu un parametru, care poate ordona sirul de inregistrari dupa un
anumit criteriu codat in valoarea intreaga primita ca parametru
(1=ordonare dupa titlu, 2=ordonare dupa artist, 3=ordonare dupa durata). Intr-o
alta clasa (PlaylistImplementation) derivata din Playlist
se implementeaza corpul metodei abstracte de sortare.
In functia main, sa se instantieze un obiect din clasa PlaylistImplementation si
apoi sa se foloseasca datele si metodele aferente.
*/
#include<iostream>
using namespace std;
#include<string.h>
class Record
{
char artist[20], titlu[20];
int min, sec;
public:
char *get_artist()
{
return artist;
}
char * get_titlu()
{
return titlu;
