1.

Fie urmatorul program:

// Public redeclarat private
// #include <iostream.h>
class A{
public:
void m(){cout<<"A:m()"<<endl;};
virtual void v(){cout<<"A:v()"<<endl;};
};
class B: public A{
private:
void m(){cout<<"B:m()"<<endl;};
virtual void v(){cout<<"B:v()"<<endl;};
};
void main(){
A a,*p;
B b;
b.m();
b.v();
// obiect de tip A
p=&a; p->m(); p->v();
// obiect de tip B
p=&b; p->m(); p->v();
}
Care expresie este incorecta:
a. b.v();
b. p=&a;
c. p->m();
d. p->v();

2. Fie urmatorul program:

// Public redeclarat private
#include <iostream.h>
class A{
public:
void m(){cout<<"A:m()"<<endl;};
virtual void v(){cout<<"A:v()"<<endl;};
};
class B: public A{
private:
void m(){cout<<"B:m()"<<endl;};
virtual void v(){cout<<"B:v()"<<endl;};
};
void main(){
A a,*p;
B b;
b.m();
b.v();
// obiect de tip A
p=&a; p->m(); p->v();
// obiect de tip B
p=&b; p->m(); p->v();
}
Care expresie este corecta:
a. b.m();
b. b.v();
c. p->f();
d. p->m();

3. Fie urmatorul program:

// Public redeclarat private
#include <iostream.h>
class A{
public:
void m(){cout<<"A:m()"<<endl;};
virtual void v(){cout<<"A:v()"<<endl;};
};
class B: public A{
private:
void m(){cout<<"B:m()"<<endl;};
virtual void v(){cout<<"B:v()"<<endl;};
};
void main(){
A a,*p;
B b;
b.m();
b.v();
// obiect de tip A
p=&a; p->m(); p->v();
// obiect de tip B
p=&b; p->m(); p->v();
}
Care expresie este corecta:
a. b.m();
b. b.v();
c. p->f();
d. p->v();

4. Fie urmatorul program:

// Public redeclarat private
// Metoda PRIVATE DEVINE ACCESIBILA PRIN MECANISMUL DE LEGARE DINAMICA
#include <iostream.h>
class A{
public:
void m(){cout<<"A:m()"<<endl;};
virtual void v(){cout<<"A:v()"<<endl;};
};
class B: public A{
private:
void m(){cout<<"B:m()"<<endl;};
virtual void v(){cout<<"B:v()"<<endl;};
};
void main(){
A a,*p;
B b;
b.m();
b.v();
 // obiect de tip A
p=&a; p->m(); p->v();
// obiect de tip B
p=&b; p->m(); p->v();
}
Care expresie este incorecta:
a. b.m(); sau b.v ()
b. p=&a;
c. p->m();
d. p->v();

5. #include <iostream.h>
class Cerc{
public:
Cerc(float r):raza(r){}
float getRaza(){return raza;}
Cerc operator++(){raza++;return *this;}// return by value
Cerc& operator--(){raza--;return *this;}// return by reference

private:
float raza;
};

void main(){
Cerc c(1.0);
cout<<(++(++c)).getRaza()<<” ”;
cout<<c.getRaza()<<” ”;
cout<<(--(--c)).getRaza()<<” ”;
cout<<c.getRaza()<<” ”;

}
Programul afiseaza:
a. 3300
b. 3201
c. 3200
d. 3211

7. Fie programul:
#include <iostream.h>
class Cerc{
public:
Cerc(float r):raza(r){}
float getRaza(){return raza;}
Cerc operator++(){raza++;return *this;}// return by value
Cerc operator--(){raza--;return *this;}// return by value

private:
float raza;
};

void main(){
Cerc c(1.0);
cout<<(++(++c)).getRaza()<<” ”;
 cout<<c.getRaza()<<” ”;
cout<<(--(--c)).getRaza()<<” ”;
cout<<c.getRaza()<<” ”;

}
Programul afiseaza :
a. 3201
b. 3200
c. 3301
d. 3211

6. Fie urmatorul program, in care se utilizeaza clase abstracte:

// abselem.h
#ifndef ABSTRACTELEM_H
#define ABSTRACTELEM_Hclass AbstractElem
{
public: virtual void display()=0; virtual void process()=0;
};
#endif
//LIST.h
#ifndef LIST_H
#define LIST_H
#include "abselem.h"
class LIST
{
public: LIST(int nrmax=0);
void put(AbstractElem *);
AbstractElem* get();
void remove();
private: int nrmax; int nrelem; int first; int free;
AbstractElem* *support;
};
#endif
//LIST.cpp
#include "LIST.h"
LIST::LIST(int nrmax):nrmax(nrmax)
{
first=free=nrelem=0; support = new AbstractElem* [nrmax-1];
}
void LIST::put(AbstractElem * pe)
{
support[free]=pe; free= ++free % nrmax; nrelem++;
}
AbstractElem* LIST::get()
{
return support[first];
}
void LIST::remove()
{
first= ++first % nrmax; --nrelem;
}Care afirmatie este adevarata:
a. 3 2 0 0
b. 3 30 1
c. 3 3 1 1
d. 3 2 1 2

8. Fie programul://destructor explicit#include <string.h>#include <iostream.h>class Person{public:

Person(char *p){name=new char[strlen(p)+1]; strcpy(name,p);} ~Person(){delete[] name;}private:
char *name;};void f(){Person *p = new Person("Balanescu"); delete p; // fara aceasta instructiune,
obiectele se acumuleaza // in heap si blocheaza executarea, spre deosebire de Java}void main(){
while(1)f();}
a obiectelor Punct in obiecte Complex
b obiectelor Complex in obiecte Punct
c obiectelor Complex in numere reale
d Numere reale in obiecte Complex

8.1 (37) Fie urmatoarea specificare de clasa:

// fileabslist.h
#ifndef ABSLIST.H
#define ABSLIST.H
#include”d:\tudor\c_cpp\abstract\abselem.h”
class AbstractList{
public:
virtual void erase()=0
virtual void put(AbstractElem*ae)();
virtual AbstractElem*get()()
virtual int in Full()()
};
#endif
Care afirmatie este corecta:
a. isEmpty() este metoda virtuala pura;
b.AbstractList este o clasa concreta;
c. AbstractList este o clasa abstracta;
d. obiectele clasei pot fi construite cu AbstractList()

9. Fie programul:
// singleton
// constructor private
#include <iostream.h>
#include <conio.h>
class S{
public:
static S* create()
{
if(i==0){
refS=new S(); i++;
}
return refS;
}
void setName(char *s){name=s;}
char* getName(){return name;}
 static int getNr(){return nr;}

private:
static S* refS;
static int i;
static int nr;
S(){nr++;}
char *name;

};

int S::i=0;
int S::nr=0;
S* S::refS=0;
void main(){
S *o1, *o2;
o1=S::create();
o2=S::create();
o1->setName("Matematica");
o2->setName("Informatica");
cout<<o1->getName()<<endl;
cout<<o2->getName()<<endl;
cout<<S::getNr()<<endl;
getch();
}
Programul afiseaza:
a. Matematica Informatica 1
b. Informatica Informatica 1
c. Informatica Informatica 2
d. Matematica Informatica 2

10. Se considera clasa:

#include "iostream.h"
template <class T>
class C{
public:
C(int nrmax=0);
void put(T);
T get();
void remove();
private:
int nrmax;
int nrelem;
int first;
int free;
T* support;
};
Temp
late <class T>C<T>::C(int nrmax):nrmax(nrmax){
first=free=nrelem=0;
support = new T [nrmax-1];
}
template <class T> void C<T>::put(T e){
 support[free]=e; free= ++free % nrmax; nrelem++;
}
template <class T> T C<T>::get(){
return support[first];
}
template <class T> void C<T>::remove(){
first= ++first % nrmax;
--nrelem;
}
a. Clasa C defineste o structura de tip coada (FIFO)
b. Clasa C defineste o structura de tip stiva (LIFO)
c. Clasa C este un vector
d. Clasa C este abstracta

10.1Fie urmatorul program, in care se utilizeaza clase abstracte:

// abselem.h
#ifndef ABSTRACTELEM_H
#define ABSTRACTELEM_H
class AbstractElem{
public:
virtual void display()=0;
virtual void process()=0;
};
#endif
//LIST.h
#ifndef LIST_H
#define LIST_H
#include "abselem.h"
class LIST{
public:
LIST(int nrmax=0);
void put(AbstractElem *);
AbstractElem* get();
void remove();
private:
int nrmax;
int nrelem;
int first;
int free;
AbstractElem* *support;
};
#endif
//LIST.cpp
#include "LIST.h"
LIST::LIST(int nrmax):nrmax(nrmax){
first=free=nrelem=0;
support = new AbstractElem* [nrmax-1];
}
void LIST::put(AbstractElem * pe){
support[free]=pe; free= ++free % nrmax; nrelem++;
}
AbstractElem* LIST::get(){
return support[first];
}
void LIST::remove(){
first= ++first % nrmax;
--nrelem;
}
Care afirmatie este adevarata:
a. LIST este o structura de date de tip coada
b. LIST este o structura de date de tip stiva
c. LIST este o clasa abstracta
d. LIST este un vector

11. Fie urmatorul program, in care se utilizeaza clase abstracte:

// abselem.h
#ifndef ABSTRACTELEM_H
#define ABSTRACTELEM_H
class AbstractElem{
public:
virtual void display()=0;
virtual void process()=0;
};
#endif
//LIST.h
#ifndef LIST_H
#define LIST_H
#include "abselem.h"
class LIST{
public:
LIST(int nrmax=0);
void put(AbstractElem *);
AbstractElem* get();
void remove();
private:
int nrmax;
int nrelem;
int first;
int free;
AbstractElem* *support;
};
#endif
//elements.h
#include "abselem.h"
#include "iostream.h"
class Person: public AbstractElem{
public:
Person(char *name);
virtual void display();
virtual void process();
private:
char *name;
};
class Car: public AbstractElem{
public:
Car(char *name);
 virtual void display();
virtual void process();
private:
char *name;
};
//driver.cpp
#include "elements.h"
#include "LIST.h"
LIST x(3);
void main(){
x.put(new Person("Tudor"));
x.put(new Person("Andrei"));
x.put(new Car("B-39-TDR"));
x.get()->process(); x.remove();
x.get()->process(); x.remove();
x.get()->process(); x.remove();
}
//LIST.cpp
#include "LIST.h"
LIST::LIST(int nrmax):nrmax(nrmax){
first=free=nrelem=0;
support = new AbstractElem* [nrmax-1];
}
void LIST::put(AbstractElem * pe){
support[free]=pe; free= ++free % nrmax; nrelem++;
}
AbstractElem* LIST::get(){
return support[first];
}
void LIST::remove(){
first= ++first % nrmax;
--nrelem;
}
//elements.cpp
#include "elements.h"
Person::Person(char *name):name(name){};
void Person::display(){cout<<name<<endl;}
void Person::process(){
cout<<"A Person: ";
display();
}
Car::Car(char *name):name(name){};
void Car::display(){cout<<name<<endl;}
void Car::process(){
cout<<"A Car:";
display();
}
Programul afiseaza datele in ordinea:
a. Tudor Andrei B-39-TDR
b. B-39-TDR Andrei Tudor
c. Andrei B-39-TDR Tudor
d. B-39-TDR Tudor Andrei
11.1
#include "iostream.h"
template <class T>
class Fifo{
public:
Fifo(int nrmax=0);
void put(T);
T get();
void remove();
private:
int nrmax;
int nrelem;
int first;
int free;
T* support;
};
template <class T>Fifo<T>::Fifo(int nrmax):nrmax(nrmax){
first=free=nrelem=0;
support = new T [nrmax-1];
}
template <class T> void Fifo<T>::put(T e){
support[free]=e; free= ++free % nrmax; nrelem++;
}
template <class T> T Fifo<T>::get(){
return support[first];
}
template <class T> void Fifo<T>::remove(){
first= ++first % nrmax;
--nrelem;
}
class Person {
public:
Person(char *name);
Person(); //necesar pentru a intializa tablouri
virtual void display();
virtual void process();
private:
char *name;
};
class Car {
public:
Car(char *name);
Car();
virtual void display();
virtual void process();
private:
char *name;
};
Person::Person(char *name):name(name){};
Person::Person(){};
void Person::display(){cout<<name<<endl;}
void Person::process(){
cout<<"A Person: ";
display();
}
Car::Car(char *name):name(name){};
Car::Car(){};
void Car::display(){cout<<name<<endl;}
void Car::process(){
cout<<"A Car:";
display();
}
Fifo<Person> queuePerson(3);
Fifo<Car> queueCar(3);
void main(){
[u]queuePerson.put(Person("Andrei"));
queuePerson.put(Person("Tudor"));
queueCar.put(Car("B-39-TDR"));[/u]
queuePerson.get().process(); queuePerson.remove();
queueCar.get().process(); queueCar.remove();
queuePerson.get().process(); queuePerson.remove();
}
A Person: Andrei
A Car:B-39-TDR
A Person: Tudor

17. Fie programul:

// destructor static,
#include <iostream.h>
class B{
public:
~B(){cout<<"~B()"<<endl;}
};
class D: public B{
public:
~D(){cout<<"~D()"<<endl;}
};
void main(){
clrscr();
B *pb;
D *pd;
pd= new D();
pb=new D();
delete pb;
delete pd;
}
Programul afiseaza :
a. ~ B() ~B() ~D()
b. ~ B() ~D()
c. ~ B()~D()~B() ~D()
d. ~ B() ~D() ~B()

17.1(41.)(34) Fie programul :

// destructor virtual,
#include <iostream.h>
class B{
public:
virtual ~B(){cout<<"~B()"<<end l;}
};
class D: public B{
public:
virtual ~D(){cout<<"~D()"<<endl;}
};
void main(){
B *pb;
D *pd;
pd= new D();
pb=new D();
delete pb;
delete pd;
}
Programul afiseaza:
a. ~ B()~D()~B() ~D()
b. ~ B() ~B() ~D()
c. ~ B() ~D()
d. ~ D()~B()~D() ~B()

18. Fie urmatorul program:

// Constructor cu semantica prin referinta
// Operatorul = este cel implicit

#include <iostream.h>
class C{
public:
C(int n=0, int v[]);
void set(int i, int val){pi[i]=val;}
friend ostream& operator<<(ostream &o, const C&);
private:
int dim;
int *pi;
};
C::C(int n, int v[]) {
dim=n;
pi= v;

}
ostream& operator<<(ostream &o, const C &m){
for(int j=0; j<m.dim; j++)o<< m.pi[j]<<" ";
return o;
}
void main(){
int a[]={1,2,3}, b[]={10,20};
C x(3,a),y(2, b);
x=y;
y.set(0,-1000);
cout<<x<<endl;
}
Programul afiseaza:
a. -100 20
b. -1000 20
c. 100 2 3
d. 1 20 30

18.1. (38) Fie programul :

// Constructor cu semantica prin referinta
// Operatorul = cu semantica prin valoare si stergere destinatie
#include <iostream.h>
class C{
public:
C(int n=0, int v[]);
C& C::operator=(C& x);
friend ostream& operator<<(ostream &o, const C&);
private:
int dim;
int *pi;
};
C::C(int n, int v[]) {
dim=n;
pi= v;
}
ostream& operator<<(ostream &o, const C &m){
for(int j=0; j<m.dim; j++)o<< m.pi[j]<<" ";
return o;
}
C& C::operator=(C& x){
// stergerea valorior din vectorul destinatie, care ori cum vor fi modificate
delete[] pi;
// atribuire
dim=x.dim;
pi=new int[dim];
for(int j=0; j<dim; j++){pi[j]=x.pi[j];}
return *this;
}
void main(){
int a[]={1,2,3}, b[]={10,20};
C x(3,a),y(2, b);
x=y ;
b[0]=-1000;
cout<<x<<endl;
}
Programul afiseaza
a. -1000 20
b. 1 2 3
c. -1000 10
d. 10 20

18.2 // Constructor cu semantica prin referinta

// Operatorul = este cel implicit
#include <iostream.h>
class C{
public:
C(int n=0, int v[]);
friend ostream& operator<<(ostream &o, const C&);
private:
int dim;
int *pi;
};
C::C(int n, int v[]) {
dim=n;
pi= v;
}
ostream& operator<<(ostream &o, const C &m){
for(int j=0; j<m.dim; j++)o<< m.pi[j]<<" ";
return o;
}
void main(){
int a[]={1,2,3}, b[]={10,20};
C x(3,a),y(2, b);
a[0]= -100;
cout<<x<<endl;
Programul afiseaza :
a. -100 2 3
b. 1 2 3
c. 100 2 3
d. 1 20 30

19. Fie programul:

#include <iostream.h>
class B{
public:
void st(){cout<< "static method st() of B"<<endl;}
virtual void v(){cout<< "virtual method v() of B"<<endl;}
};
class D: public B{
public:
void st(){cout<< "static method st() of D"<<endl;}
virtual void v(){cout<< " virtual method v() of D"<<endl;}
};

int main(){
B *pb;
D d;
// pointing to a subclass
pb=&d;
((D*)pb)->v();
((D*)pb)->st();
return 0;
}
Programul afiseaza:
a. virtual method v() of D
static method st() of D
b. virtual method v() of B
static method st() of D
c. virtual method v() of D
static method st() of B
d. virtual method v() of B
static method st() of B

20. Fie programul:

#include <iostream.h>
class B{
public:
void st(){cout<< "static method st() of B"<<endl;}
virtual void v(){cout<< "virtual method v() of B"<<endl;}
};
class D: public B{
public:
void st(){cout<< "static method st() of D"<<endl;}
virtual void v(){cout<< " virtual method v() of D"<<endl;}
};
int main(){
B b, *pb;
D d, *pd;
pb=&d;
pb->st();
pb->v();
return 0;
}
Programul afiseaza:
a. static method s() of D
virtual method v() of D
b. static method s() of B
virtual method v() of B
c. static method s() of D
virtual method v() of B
d. static method s() of B
virtual method v() of D

21. Fie programul#include <string.h>#include <iostream.h>class Person{public: Person(char *p){nr=0;

name=new char[strlen(p)+1]; strcpy(name,p); nr++; cout<<nr<<endl; } ~Person(){delete[]
name;}private: char *name; long nr;};void f(){Person *p = new Person("Balanescu"); delete p;}void
main(){ for (int i=0; i<5; i++)f();}Programul afiseaza:
avirtual method v() of Dstatic method st() of D
bvirtual method v() of B static method st() of D
c virtual method v() of Dstatic method st() of B
dvirtual method v() of Bstatic method st() of B

22. Fie programul :

// constructor de copiere in clasa de baza; dar absent in clasa derivata
// compilatorul creeaza un constructor de copiere implicit
// care apeleaza constr de copiere al clasei de baza pentru copierea atributelor din clasa de baza
// si copiaza membru cu membru atributele din D
#include <iostream.h>
class B{
public:
B(){cout<<"B()"<<endl;}
B(B &b){cout<<"B(B &b)"<<endl;}
};
class D: public B{
public:
D(){cout<<"D()"<<endl;}
};
void main(){
B b; // apel B()
B b1(b); // apel B(B & ); nu se mai utilizeaza B()!
D d; // apel B();D()
D d1(d);
B bd(d); // conversie implicita la clasa de baza;
getch();
}
Programul afiseaza :
a. B() B() B(B&b) B() D() B(B &b) B(B &b)
b. B() B() B(B&b) B() D() B(B &b) D() B(B &b)
c. B() B(B&b) B() D() B(B &b) B(B &b)
d. B() B(B&b) D() B(B &b) D() B(B &b)
22.1 Fie programul
// constructor de copiere in clasa de baza; dar absent in clasa derivata
// constructorul de copirere din clasa derivata utilizeaza pe B() pentru constructia // // subiectului B
#include <iostream.h>
class B {
public:
B(){cout<<"B()"<<endl;}
B(){cout<<B(B&b)” << endl;)
};
classD public B:
public:
D()cout<<”D()<<”endl;)
D(D&d)cout << “D(D&d)”<<endl;)
};
void main(){
Bb; // apel B()
Bb1(b); // apel B(B&) nu se mai utilizeaza B()!
D d; // apel B();D()
D d1(d); // nu se apeleaza B(B&b)
}
Programul afiseaza:
a. B() B(B&b) B() D() B(B &b) D(D &d)
b. B() B(B&b) B() D() B() D(D &d)
c. B() B() B(B&b) B() D() B(B &b) D() B(B &b)
d. B() B(B&b) D() B(B &b) D() B(B &b)

25. Fie programul:

A class Persoana{
public:
Persoana(char * n){nume=n;}
 void afisare(){cout<<nume<<endl;}
char *nume;
};
Constructorul Persoana(char *) poate fi utilizat pentru:
Conversia obiectelor Persoana in siruri de caractere
Conversia sirurilor de caractere in obiecte Persoana
Construirea de siruri de caractere
Conversia obiectelor Complex in obiecte Persoana

B Fie programul:
//destructor explicit
#include <string.h>
#include <iostream.h>
class Person{
public:
Person(char *p){name=new char[strlen(p)+1]; strcpy(name,p);}
~Person(){delete[] name;}
private:
char *name;
};
void f(){Person *p =
new Person("Balanescu");
delete p;
// fara aceasta instructiune, obiectele se acumuleaza
// in heap si blocheaza executarea, spre deosebire de Java
}
void main(){
while(1)f();
}
a. La iesirea din functia f(), spatiul alocat pentru sirul de caractere “Balanescu” nu este eliberat si
memoria va fi epuizata
b. La iesirea din functia f(), spatiul alocat pentru sirul de caractere “Balanescu” este eliberat
c. Programul se termina datorita epuizarii memoriei
d. Programul se termina dupa primul apel al functiei f()

(la aia cu while) b (aia cu balanescu)

26. Fie urmatorul program:

#include <iostream.h>
class A{
public:

void s(){cout<<"void A::s()"<<endl;}

void s(int i){i++;cout<<"void A::s(int)"<<endl; }
virtual void v(){cout<<"virtual void A::v()"<<endl;}
virtual void v(int i){i++;cout<<"virtual void A::v(int)"<<endl;}
};
Care afirmatie este corecta:
a. Definitia virtual void v()supraincarca definitia virtual void v(int i)
b. Definitia virtual void v(int i) este incorecta deoarece exista o definitie pentru metoda v.
c. void v() este metoda ce va fi legata static.
d. in expresia p->v(); metoda v este legata static
 27. Fie urmatorul program:
// Constructor cu semantica prin referinta
// Operatorul = este cel implicit
#include <iostream.h>
class C{
public:
C(int n=0, int v[]);
friend ostream& operator<<(ostream &o, const C&);
private:
int dim;
int *pi;
};
C::C(int n, int v[]) {
dim=n;
pi= v;
}
ostream& operator<<(ostream &o, const C &m){
for(int j=0; j<m.dim; j++)o<< m.pi[j]<<" ";
return o;
}
void main(){
int a[]={1,2,3}, b[]={10,20};
C x(3,a),y(2, b);
a[0]=-100;
cout<<(x=y)<<endl;
Programul afiseaza: 10 20
28. Fie programul :
#include <iostream.h>
class Cerc{
public:
Cerc(float r):raza(r){}
float getRaza(){return raza;}
void operator++(){raza++;}
private:
float raza;
};
class Cilindru: public Cerc{
public:
Cilindru(float raza, float inaltime):Cerc(raza), inaltime(inaltime){};
void operator++(){inaltime++;}
float getInaltime(){return inaltime;}
private:
float inaltime;
};
void main(){
Cerc *pc;
Cilindru c(1,5);
pc=&c;
++ *pc;
cout<<pc->getRaza()<<" "<<c.getInaltime()<<endl;
getch();
}
Programul afiseaza :
a. 1 6
b. 2 5
c. 2 6
d. 1 5

29. Fie programul:

#include <string.h>
#include <iostream.h>
class Person{
public:
Person(char *p){name=new char[strlen(p)+1]; strcpy(name,p);
nr++; cout<<nr<<endl;
}

private:
char *name;
static long nr;
};
long Person::nr=0;
void f(){Person *p =
new Person("Balanescu");
delete p;
}
void main(){
while(1)f();
}
Care afirmatie este adevarata:
a. Programul afiseaza un sir finit de numere 1 2 3 4...etc. pana memoria este epuizata
b. Programul afiseaza secventa infinita 1 2 3 4...etc. deoarece memoria nu este epuizata
c. Programul nu afiseaza nimic
d. Programul afiseaza 1 apoi se opreste

30. Fie programul

//static atribut
#include <conio.h>
#include <string.h>
#include <iostream.h>
class Person{
public:
Person(char *p){name=new char[strlen(p)+1]; strcpy(name,p);
nr++; cout<<nr<<endl;
}
~Person(){nr--; delete[] name;}
private:
char *name;
static long nr;
};
long Person::nr=0;
void f(){Person *p =
new Person("Balanescu");
}
void main(){
 for (int i=0; i<5; i++)f();
getch();
}
Programul afiseaza:
a. 1 2 3 4 5
b. 1 1 1 1 1
c. 0 0 0 0 0
d. 0 1 2 3 4

31. Fie programul:

class Persoana{
public:
Persoana(char * n){nume=n;}
void afisare(){cout<<nume<<endl;}
char *nume;

};
Constructorul Persoana(char *) poate fi utilizat pentru:
a. Conversia obiectelor Persoana in siruri de caractere
b. Conversia sirurilor de caractere in obiecte Persoana
c. Construirea de siruri de caractere
d. Conversia obiectelor Complex in obiecte Persoana
35 Fie urmatoarea specificare de clase:
class Complex;
class Punct{
public:
Punct(float x=0, float y=0):x(x),y(y){}
operator Complex();
operator float(){return x;}
private:
float x,y;
};
class Complex{
public:
Complex(float x=0, float y=0):x(x),y(y){}
operator Punct(){return Punct(x,y);}
operator float(){return x;}
private:
float x,y;
};Metoda Complex:: operator float() este utilizata pentru
a. Conversia unui numar real in obiect Complex
b. Conversia unui obiect Complex in obiect Punct
c. Conversia obiectelor Complex in numere reale
d. Conversia unui obiect punct in obiect Complex
40. Se considera clasa:
#include "iostream.h"
template <class T>
class C{
public:
C(int nrmax=0);
void put(T);
T get();
void remove();
private:
int nrmax;
int nrelem;
int first;
int free;
T* support;
};
template <class T>C<T>::C(int nrmax):nrmax(nrmax){
first=free=nrelem=0;
support = new T [nrmax-1];
}
template <class T> void C<T>::put(T e){
support[free]=e; free= ++free % nrmax; nrelem++;
}
template <class T> T C<T>::get(){
return support[first];
}
template <class T> void C<T>::remove(){
first= ++first % nrmax;
--nrelem;
}
a. Clasa C este o clasa generica
b. Clasa C este o clasa abstracta
c. Clasa C este derivata din clasa T
d. Clasa T este derivata din clasa C

43. Fie urmatorul program:

#include <iostream.h>
class A{
public:
// supraincaracre void s()
void s(){cout<<"void A::s()"<<endl;}
void s(int i){i++;cout<<"void A::s(int)"<<endl; }
// supraincarcare void v()
virtual void v(){cout<<"virtual void A::v()"<<endl;}
virtual void v(int i){i++;cout<<"virtual void A::v(int)"<<endl;}
};
class B:public A{
public:
// 1. supraincarcare metoda statica
int s(){cout<<"int B::s()"<<endl; return 1 ;}
// 2. specializare metoda statica
void s(int i){i++;cout<<"void B::s(int)"<<endl; }
// 3. specializare metoda virtuala
virtual void v(int i){i++;cout<<"virtual void B::v(int)"<<endl;}
};
void main(){
A *pa;
B b;
pa=&b; pa->s(); pa->v(1);
}
Prin executarea sa, programul afiseaza:
a. void B::v()
void A::v(int)
b. void A::v()
void B::v(int)
c. void A::s()
void B::v(int)
d. void A::v()
void A::v(int)

43.1
#include <iostream.h>
class A{
public:
// supraincaracre void s()
void s(){cout<<"void A::s()"<<endl;}
void s(int i){i++;cout<<"void A::s(int)"<<endl; }
// supraincarcare void v()
virtual void v(){cout<<"virtual void A::v()"<<endl;}
virtual void v(int i){i++;cout<<"virtual void A::v(int)"<<endl;}

};
class B:public A{
public:
// 1. supraincarcare metoda statica
int s(){cout<<"int B::s()"<<endl; return 1;}
// 2. specializare metoda statica
void s(int i){i++;cout<<"void B::s(int)"<<endl; }
// 3. specializare metoda virtuala
virtual void v(int i){i++;cout<<"virtual void B::v(int)"<<endl;}
};
//4.supraincarcare metoda virtuala,
virtual void v(){count<<"int B::()"<<endl:return1}
};

44Fie următorul program C++, unde functia abs calculează valoarea absolută a unui număr real:
#include <iostream.h>
void abs(float &x){if (x<0)x=-x;}
void main(){
float a=-1;
abs(a);
cout<<"a="<<a<<endl;
int i=-1;
abs(i); //temporary used for parameter x
cout<<"i="<<i<<endl; // i=-1
}

Care din afirmatiile următoare sunt adevărate:

a. Programul afisează:
a =1
i = -1
b. Programul afisează:
a =1
i=1
c. Programul afisează:
a = -1
i = -1
d. Programul afisează:
a = -1
i=1

45 Fie următorul program C++:

#include <iostream.h>
class Persoana{
public:
Persoana(char * n){nume=n;}
void afisare(){cout<<nume<<endl;}
char *nume;
};
Persoana q="Balanescu";
void fvalue(Persoana p){p.afisare();}
void faddress(Persoana *p){p->afisare();}
void freference(Persoana &p){p.afisare();}
void main(){
fvalue(q);
faddress(&q);
freference(q);
fvalue("Tudor");
freference("Tudor");// Warning: temporary used for p
}
Care din afirmatiile următoare sunt adevărate:
a. Expresia faddress(&q); este eronată;
b. Instructiunea de declarare Persoana q="Balanescu"; este eronată;
c. Expresia p->afisare() este eronată;
d. Programul afisează:
Balanescu
Balanescu
Balanescu
Tudor
Tudor