25.01.

2017
Spre deosebire de limbajele orientate pe obiect C++ permite controlul accesului la
membrii claselor în acest scop sau creat 3 specificatori de control al accesului:
 PUBLIC -membrul poate fi accesat de orice funcție din domeniul declarație
clasei (nu are restricții )
 PRIVATE-Membrului este accesibil numai funcțiilor membre și prietene ale
clasei.
 PROTECTED- Similar cu private,însă accesul se extinde și la funcțiile
membre și prietene ale claselor derivate.
Este de remarcat faptul că o funcție membre a unei clase are acces la toți membrii
clasei indiferent de specificatorul de acces.
Asa dar sintaxa de declarație unei clase derivate incluzind controlul accesului
este:
Class Nume clasa derivată :Specificatorul de acces ,Nume clasa de bază.
Ex class Persoane
{char nume [10];
Char prenume[10];
Int virsta;
}
Class Elev: public Persoană
{ void afișare (int,persoana [])
}

Atributul din clasa de baza

Atributul din clasa Modificatorul de Accesul moștenit Accesul în
de baza acces de clasa derivată exterior
Private. PRIVATE Inaccesibil Inaccesibil
PUBLIC. PRIVATE Privat Inaccesibil
PROTECTED. PRIVATE Privat Inaccesibil

Privat Public Inaccesibil Inaccesibil

Protected Public Protected Inaccesibil
Public Public Public Accesibil

Observăm Pentru a oferi clasei derivate acces la.un membru al clasei de bază,acesta trebuie declarat
protected sau public pentru respectarea principiului incapsularii datelor pentru respectarea principiului
incapsularii datelor datele membre pentru care se oferă acces claselor derivate se declara in clase de
bază cu atributul Protected..

De asemenea pentru a observa dreptul de acces în urma derivarii se utilizează derivarea public .

Accesul poate fi stopat pe orice nivel ar erahiei de clase printr-o derivare Private.

Class Point

{protected:

Unsigned x,y;

Public:

Point ()

Point (unsigned x,unsigned y);

~Point ();

Unsigned long Arie ();

Unsigned GetX ();

Unsigned GetY ();

Void SetX (unsigned x);

Void SetY (unsigned y);

Class Graphic Point: public Point

{unsigned color;

Public:

Graphic Point (unsigned x,unsigned y);

~Graphic Point ();

Void Draw ();

Void SetX (unsigned x);

Void SetY (unsigned Y);

};
Observăm ca variabile membru sunt declarate Protected astfel incit vor fi vizibile și vor avea același
atribut în clasa Graphic Point deși nu sunt utilizate în mod normal X si Y ar trebui sa fie declarați Private
întru cit nu sunt utilizați decit în interiorul clasei Point.

Funcțiile din Graphic Point nu accesează acești 2 membri direct ci prin intermediul metodelor publice de
accesare a lor oferite de clasa Point .

De notat este faptul că implicit dacă nu este utilizat nici un specificator de acces membrii sunt Private.

Accesul la datele membre publice sau apelul funcțiilor membre publice ale unui obiect se poate face
folosind un operator de selecție membru:operatorul . Dacă se cunoaște obiectul sau operatorul – dacă
se cunoaște pointerul la obiect

Funcțiile friend funcțiile inline si membrii statici.

Public:

Int setY(int c=0) {y=c;}

Void suma (B&);

};

Class B

{private :

Int x;

Public :

Int GetX () {return x;}

Void SetX (int a) {int=a;}

Friend class A

};

Void A ::Suma (B&ob)

Ab.x+=y;

Int main (){

A a;

B b;

a.setY (10);

b.setX (7);
a.suma (b);

cout <<b.GetX ();

01.02.2017

Funcții Inline C++

Diferenta dintre o funcție inline și una uzuală constă în faptul că fiecare apel al funcției inline este
înlocuit de compilator cu codul funcției.

Avantajul constă în creșterea vitezei de execuție a codului.Fiind evitate operațiile aferente apelului de
funcție.

Exemplu :Alocarea pe stiva a memorie necesare apelului,copierea valorilor ,parametrilor,returnarea

valorii calculate de funcție.

Dezavantaj-Crește dimensiunea codului sursă. Din punct de vedere sintactic definiția unei funcții
INLINE este similară cu cea a funcției uzuale,doar este precedată de cuvintul cheie INLINE.

CODUL :

Inline int max (int a,int b)

{return a>b ?a:b;

Main ()

{….

Max (5,7);

#include <iostream>

Using namespace std;

Inline int double (int target )

{return 2×target;

Int main ()

{int target;

Cout <<»enter a number»;

Cin>>target;

Cout <<»/n»;
Target =double (target);

Cout <<target=»target <<endl;

Target =double (target);

Cout <<»target»<<target<<endl;

Target = double (target);

Cout <<»target « <<target<<endl;

Return 0; {

OBSERVAT:

Funcții inline trebuie sa fie foarte scurte.

Funcțiile récursive nu pot fi funcții inline.

Compilatorul poate ignora declarația inline.

Funcțiile inline combin ăavantajele macrourilor cu cele ale funcțiilor în acest caz se elimină operațiile
aferente apelului. Păstrează toate proprietățile funcțiilor referitor la validitatea apelului ,transferur
parametrilor,declarații.

Funcțiile membre definite în declarația clasei sunt implicit funcției inline.

Constructorii in C++

Constructorii sunt metode speciale ale clasei care au caracteristici speciale pe se folosesc la.crearea si
inițializarea unei clase .

Sunt apelați de fiecare data când se creaza noi instanțe ale clasei(automat la crearea fiecărui obiect al
clasei).

Numele constructorilor coincide cu numele clasei

Apelul constructorului se realizează la.declararea unui obiect.

Pot fi supraîncărcați (ca si functiile).

În declarația /definiția unui constructor nu se specifică tipul rezultatului.

O clasă poate avea mai mulți constructori.

Se executa consecutiv una după alta .

Dacă nu este specificat nici un constructor compilatorul generează automat unu implicit fără parametrii .

Funcția constructor este o metodă publică.

Programatorul își poate defini constructor proprii.

#include <iostream>;

Using namespace std;

Class line

{public :
Void setlonght (double len){lenght=len,}

Double GetLenght(void) {return lenght};

Line ();//constructor

Private:

Double lenght;

};

Line ::line(void)

{cout <<'object is created '<<endl;}

Int main ()

{Line line;

Line setlength(6.2);

Cout<<'Lenght of line':<<line.getLenght ()<<endl;

Distructorii în C++

Este o funcție specială a unei clase.

Este apelata automat la eliminarea unui obiect ai clasei:

 La încheierea ciclului de viață al obiectului.

 În cazul obiectelor dinamice cind este utilizat operatorul DELETE.

Daca în cadrul clasei nu este explicit declarat un destructor, compilatorul generează automat unu
implicit.

 Destructorii nu pot fi supraîncărcați.

 Are același nume ca si clasă precedat de caracterul TILDA ~.
 Nu are argumente și nici tip rezultat.

08.02.2017
Tema:Operatorul THIS(pointerul THIS)
La crearea instanței se creează un pointer special denumit THIS.
this conține adresa instanței curente a obiectului.

Se folosește la accesarea metodilor (funcții ).

Mulți recurg la ele pentru mai multa claritate.

Pointerul THIS este deosebit față de alți pointeri valoarea sa se modifică la fiecare nouă apelare a
instanței.

Program:

#include <iostream>

Using namespace std;

Class A {

Private:

Int a;

Int b;

Public:

Int gets(int x, int y)

{ a=x ; b=y;

Int produs_this(int,int)

{ cout <<''Function using ) this:''<<(this->a)*(this->b)<<endl;}

Int produs ()

{cout <<'simple function'<<a*b;}

Main ()

{A obj;

Int x,y;

Cout <<'x='; cin>>x;

Cout <<''y=''; cin>>y;

Obj.gets (x,y);

Obj.produs_this (x,y);

Obj.produs ();

Supraîncărcarea funcțiilor (owloanding function )

Program (suma a două numere reale si a 2 numere întregi ):

#include <iostream>

Using namespace std;

Class Suma {

Private:

Int x;

Int y;

Public:

Int suma (int,int)

{cout <<'' Suma of.2 integers :''<<x+y;

Double Suma (double,double)

{cout<<''Sum of 2 doubles:''<<x+y;}

Main ()

{Sum.Obj;

Obj.Suma (3,4);

Obj.Suma (2.5,1.5);

ALT PROGRAM :

#include <iostream>

Using namespace std;

Int suma (int x,int y)

{cout <<'' Suma of.2 integers :''<<x+y;

Double Suma (double x,double y)

{cout<<''Sum of 2 doubles:''<<x+y;}

Main ()
{

Suma (3,4);

Suma (2.15,1.5);

Supraîncărcarea operatorilor

Acasa: Creați un program care va utiliza supraîncărcarea operatorilor. Citiți 2 vectori cu un constructor
în clasa de bază, executați următoarele operații :

A:Suma a 2 tablouri undimensionale.

B:Diferenta a 2 vectori.

C:Produsul a 2 vectori.

D:Produsul scalar a 2 vectori.

E:++Postfixat incrementat .

F:Postfixat decrimentat.

G:<< Operator de afisare.

J:>>Operator de citire.

Supraîncărcarea Funcțiilor.

Cea mai puternică facilitate introdusăde limbajul C++ referitor la funcții constă în posibilitatea de
supraîncărcare a funcțiilor. Supraîncărcarea oferă programatorului mai multe funcții cu același nume dar
care diferă prin numărul și bară sau tipul parametrul .

Programul:

#include <iostream >

Using namespace std;

Double functiamea (double i);

Int functiamea (int i);

Main ()

{
Cout <<functiamea (10)<<>>;

Cout <<functiamea (5,4);

Return 0;

Double functiamea(double i)

{ return i;

Int functiamea (int i);

{ return i;

Programul NR 2:

#include <iostream >

Int functiamea (int i);

Int functiamea (int i,int y);

Main ()

{cout <<functiamea(10)<<'' '';

Cout <<functiamea (4.5);

Return 0;}

Double functiamea (int i)

{return 0;}

Int functiamea(int i,int j)

{return i*j;}

Text:

Probabil cel mai frecvent caz de ambiguitate apare apare din cauza funcție sqrt().

Funcția SQRT este supraîncărcată astfel:

Long double sqrt (long double);

Float sqrt (float);

Double sqrt (double);

Un apel de tip:
Int x

Sqrt (x); //ERROR;

Destructorii

Cind creăm o instanță obiect se execută automat o funcție constructor.

În mod asemănător se permite definirea unei funcții distructor .

Program:

#include <iostream >

Using namespace std;

Class A

Public:

A ();//constructor;

~A () ;//destructor;

};

A::A ()

{cout <<''obiect s-a creat''<<endl;

A::~A ()

{cout <<''obiectul sa distrus ''<<endl;

Int main (void)

{A ob.obr;

};

Necesitatea funcțiilor destructor :

 Funcții destructor nu executa o prelucrarea speciala.

 La eliberarea memoriei unde pot fi utilizate operații specifice listelor (LSI,LDI) in cadrul funcțiilor
destructor.
 Cind se realizează eliberarea memoriei alocate dinamic pentru memorarea unor obiecte
,folosind operatorul DELETE .
 La părăsirea domeniului de existența al unei variabile .

Modelul logic al vieții unui obiect:

  Instanță este creată .
 Se execută funcția constructor.
 Obiectul trăiește .
 Se execută funcția destructor.
 Obiectul este distrus.

#include <iostream >

#include <stdioh>

Using namespace std;

Class Vector

{Public :

Int element [10];

Int n,i;

Vector();

Void operator+(vector);

Void operator-(Vector);

~Vector ();

};

Vector::Vector ()

{ printf (''Introduce numărul de elemente in vector:'');

Cin>>n;

Cout <<''Introduceți elementele vectorului:'';

For (i=1;i <=n;i++)

15.02.2017
#include <iostream>

Using namespace std;

Class Supra

Public:

Int num;

Supra ();
Supra (int);

Supra operator+(Supra);

Void display;

Supra::Supra (){ }

Supra::supra (int a)

Num=a;}

Supra Supra::operator+(supra b);

{ Supra obj;

Obj.num=num+b.num;

} return (obj)

Void Supra::Display ()

{cout <<num <<endl;

Int main ()

Supra x (3),y (4),z;

Z=x+y

Z.display ();

Utilizați o clasă vector care va inițializa printrun constructor elementele a doi vectori tablou
unidimensional.

Implimentati operatorul de adunare (+) scădere(-) produs (×) produs scalar (×=) implimentarea (++)
deplimentarea (--).

Program:Adunarea

#include <iostream>

Using namespace std;

{ public:

Int a [10];

Int i,n;

();
~vector ();

Void operator+(vector);

};

Vector::vector ()

{cout <<''Dati n=''>>;

Cin>>n;

Cout <<'elem vect'';

For (i=0,i <n;i++)

{cout <<''a [''<<i+1 <<'']='';

Cin>a [i];

Cout <endl;

Vector::~vector ()

{}

Void vector::operator+(vector v1);

{cout <<''Adunarea vectorului :''<<endl;

For (i=0;i <n;i++)

Cout <<a [i]+v1.a [i];

Cout <<endl;

Main ()

{ vector v1,v2;

v1+v2;//+

… //-,*,*=

Program:Înmulțirea

#include <iostream>

Using namespace std;

{ public:

Int a [10];

Int i,n;
();

~vector ();

Void operator+(vector);

};

Vector::vector ()

{cout <<''Dati n=''>>;

Cin>>n;

Cout <<'elem vect'';

For (i=0,i <n;i++)

{cout <<''a [''<<i×1 <<'']='';

Cin>a [i];

Cout <endl;

Vector::~vector ()

{}

Void vector::operator+(vector v1);

{cout <<''Adunarea vectorului :''<<endl;

For (i=0;i <n;i++)

Cout <<a [i]×v1.a [i];

Cout <<endl;

Main ()

{ vector v1,v2;

v1×v2;//+

… //-,*,*=

Program:Produs scalar

#include <iostream>

Using namespace std;

{ public:
Int a [10];

Int i,n;

();

~vector ();

Void operator+(vector);

};

Vector::vector ()

{cout <<''Dati n=''>>;

Cin>>n;

Cout <<'elem vect'';

For (i=0,i <n;i++)

{cout <<''a [''<<i×1 <<'']='';

Cin>a [i];

Cout <endl;

Vector::~vector ()

{}

Void vector::operator×=(vector v1);

{cout <<''Produs scalar''<<endl;

Int p=0;

For (i=0;i <n;i++)

Cout <<a [i]×v1.a [i];

P=p+a [i]×v1.a [i];

Cout <<p <<endl;

Main ()

{ vector v1,v2;

v1×v2;//+

… //-,*,*=
}

POO TEORIE

Limbajul C++ permite operatorului sa facă diferite operații cu obiecte ale claselor folosind simbolurile
operatorilor standart.

Un tip clasă se poate defini împreună cu un set de operatori asociați obținut prin supraîncărcare
(overloading ) operatorilor existenți.

Procedeul constă în definirea unei funcții cu numele : Operator''Simbol'' EX:OPERATOR + unde

operatorul este cuvint cheie dedicat simbol. (+,-,++,--,×,÷,×=, <<,>>) .

Nu pot fi supraîncărcați următorii operatori :

 De rezoluție-::
 Pointer-*
 Operatorul condiției-:?
 Size of- mărimea tipului de date.
 .-operatorul punct.

Modalități de supraîncărcare a operatorilor :

 Funcții membru
 Funcții prietene (Friend).

Sintaxa :

Class IDClasa

{tip_rez operator simbol (listă parametri)

};

Add (listă parametri)

Add operator+(Add)

Moștenirea reprezinta unul din principele fundamentale moștenirea reprezintă unul din principiile
fundamentale ale POO care dintrun concept general sa obținem unul particular (mai specializata ) .
Moștenirea reprezintă mecanismul prin care o clasă preia structura( datele membre.) Si
comportamentul  (metodele ) unei altei clase la care adaugă elementele specifice.
Moștenirea reprezintă procesul prin care o clasă derivată moștenește toate datele si funcțiile membre
ale unei clase numită clasa de bază.
Clasa de bază se mai numește  (Părinte.Casa Părinte sau Super Clasa). Clasa de la care se preia structura
si comportamentul .
Clasa  se diferențiază de clasa  de bază prin adăugarea unor membri  (Date sau funcții )..Sau prin
supraîncărcarea funcțiilor membre al clasei de bază.
Utilizând derivatele claselor dezvoltarea aplicațiilor devin mai eficiente .
1.O parte de cod este deja scrisă și va fi moștenită .
2. Codul Moștenit deja este testat, deci exista o garanție a corectitudinii acestuia.
Derivarea unei clase dintro clasă de bază .

Class Derivat:[modificatorul de acces] clasa Baza

{ Proprietati ; (var )

Metode (func ())

};

Modificatorul de acces poate fi:

 Public
 Protected
 Privat

Exemplu:

Class Daughter :public mother

{into

Void output ()

{cout <<'' derived function ''>;}

};

Ce moștenim în principiu fiecare dată sau funcție membru a clasei de bază e moștenește în clasă
derivată

Diferă doar protecția acestora.

Există și excepții :

 Constructori și destructorii.
 Supraîncărcarea operatorului =
 Prietenilor(datele din clasele friends ).

Acestea nu se moștenesc fiind metodele specifice claselor.

Efectul specificatorilor de acces asupra membrilor de bază :

Acces Public Protected Private

Membrii ai Da Da Da
aceiași clase .
Membrii ai Da Da Nu
clasei derivate
Nu sunt Da Nu Nu
membrii

#include <iostream >

Using namespace std;

Class mother

{public:

Void SayName();

};
Void Mother ::sayname ()

Cout <<''Base class''<<endl;

Class Dougther :public Mother;

{ public :

Void f2 (cout <<'' Derived class'' <<endl;

}; int main ()

{ Mother mom;

Mom.Sayname ()

Doughter tina;

Tina.sayName ();

Tina.f2 ();

А 2Exemplu:

01.23.2017
1-Se da o clasă de bază poligon care conține lungimea și lățimea de tip întreg cu specificatorul
PROTECTED.

Ia conține de asemenea o metodă publică care setează lungimea si lățimea.

Clasa dreptunghi deriva din clasa poligon și conține metoda ariei -calculează aria dreptunghiului.

Clasa triunghi derivă din clasa poligon și conține metoda ariei -Calculează aria tringhiului. Asigurați
corect incapsulara și moștenirea simplă.

2-Inplimentati o erahi de clase ce reprezintă diferite figuri geometrice din plan. Utilizați moștenirea
multiplă.

PE ACASA: Implimentati erarhia de clase telefon, fix , telefon,mobil utilizați moștenirea multiplă
(Asigurăm incapsulara ).

01.03.2017

Moștenirea protejată a clasei

Atunci cind moșteniți o întreagă clasă ca Protected in sintaxa de moștenire toți membrii publici și
protejați ai clasei de bază devin membrii protejați ai clasei derivate.

Deci are loc transformarea tuturor membrilor clasei baze în membrii privați în cadrul clasei derivate .

PROGRAM 1:

#INCLUDE

Using namespace std;

Class Baza

{protected :

Int a,b;

Public :

Void Set (int x,int y)

A=x;

B=y;
Void Show ()

Cout <<a <<'' ''<<b <<endl;

Class Deriv1:protected baza

{Private :

Int k;

Public:

Void setk ()

{Set (2,3);

K=a*b;

Void showK ()

Cout <<''K=''<<endl;

};

Int main ()

Deriv_1 obj;

Obj.setk ();

Obj.showk ();

//Obj.set ();// acces ilegal

//Obj.show ();//acces ilegal

PROGRAM2:

#include <iostream>

Using namespace std;

Class Baza

{protected :

Int b;

Public :
Baza ()

{cout <<''Apel Baza''<<endl;

};

Class Deriv_1:public Baza

{protected:

Int c;

Public :

Deriv_1 ()

{cout <<''Apel Deriv_1''<<endl;

};

Main ()

{Deriv_1 d;

Constructorii fără parametrii in procesul de moștenire

Dacă constructorii clasei derivate nu apelează explicit constructor uneia din clasele de bază atunci
compilatorul va fi apelat automat de constructorul implicit ai clasei de bază.

Program 3 :

#include <iostream >

Using namespace std;

Class Baza

{protected:

Int b;

Public:

Baza ()

{ cout <<''Apel Baza''<<endl;

};

Class Deriv_1

{public:
Deriv_1

{public :

Deriv_1 ()

{cout<<''Apel Deriv_1''<<endl;

};

Class Deriv_2:public Baza Deriv_1

{public :

Deriv_2 ()

{cout <<''Apel Deriv_2''<<endl;

Main ()

{Deriv_2 d;

Constructorul in moștenirea multiplă :

Class Baza

{Baz ();

Clasa Deriv_1

{de}

(Nu lam terminat)

Constructorii în moștenirea multiplă (fără parametrii )

#include <iostream >

Using namespace std;

Class Baza

{ protected :

Int b;

Public:

Baza ()
Class Baza

{public:

Baza ();

};

Clasa Deriv_1

{public:

Deriv ()

};

Class Deriv_2:public Baza,Deriv_1

{Deriv_2 ();

};

Main ()

{Deriv_2 dr (un obiect);

Destructorii în procesul de moștenire

La distrugerea unui obiect al clasei derivate compilatorul va executa mai întîi destructorul clasei derivate
și apoi destructorii claselor de bază în ordinea inversă a apelului constructorilor

Program4:

#include <iostream >

Using namespace std;

Class Baza

{public:

~Baza ()

{cout <<''Destructor Baza''<<endl;

};

Class Deriv_1

{public:

~Deriv_1

Semnul ~ înseamnă ca este destructor.

{cout''Destructor Deriv_1 <<endl;

}

};

Class Deriv_2:public Baza,Deriv_1

{public:

~Deriv_2 ()

{cout <<''Destructor Deriv_2''<<endl;

};

Main ()

{Deriv_2 d2;

Va afișa :

Destructor Der2

… Der1

… Bază

Constructor fără parametrii VS constructor cu parametrii în procesul moștenire

Cu toate ca constructorii și distructorii ai clasei de bază nu sunt însăși moșteniți, constructorul implicit
(fara parametrii ) și distructor său sunt întotdeauna apelate atunci cind un nou obiect al unei clase
derivate este creată sau distrusă.

Program 5:

#include <iostream>

Using namespace std;

{public:

Mother ()

{cout <<''mother :no parameters '';

Mother (int a)

{cout''mother:int parameter '';

};

Class Daughter :public mother

{public:

Daughter (int a)// const cu parametrii

{cout''Doughter :int parameters '';

};

Class son :public mother

{public :

Son (into) :mother (a)

{cout <<''son:int parameter''<<endl;

};

Int main ()

{daughter cyntia (0)

Son Daniel (0)

15.03.2017
Tema:Polimorfismul
Poliorfismul reprezintă un alt principiu fundamental al POO.

Cuvintul Polimorfism descrie posibilitatea de a avea mai multe forme.

În C++ apelul unei funcții membre Va avea un efect diferit în funcție de obiectul care invoca funcția
(Funcția apelata este selectată în funcție de tipul obiectului ) .

Polimorfism este capacitatea unor entități de a lua forme diferite. El include referințe pointeri impliciti
clase abstracte funcții virtuale funcții virtuale pure.

Poliorfismul parametric :

Reprezintă mecanismul prin care putem defini o metodă cu același nume în aceiași clasă funcții care
trebuie sa difere prin numărul și \Sau tipul parametrului. Selecția funcției se realizează la compilare
(early binding)

Programul :

#include <iostream>

Usingnamespace std;

Class Suma
{

Public:

Int x,y,z;

Public:

Int Suma (int x,int y)

{return (x+y)};

Int Suma (Int x,int y,int z)

{return (x+y+z);}

};

Main ()

{Suma obj;

Int a=2;b=3;c=4;

Cout <<''Suma a 2 numere''<<obj.suma (a,b)<<endl;

Cout <<''Suma a 3 numere:''<<obj.suma (a,b,c)<<endl;

Polimorfismul de moștenire :

Mecanismul prin care o metodă din clasa de bază este redefinită cu aceiași parametri în clasele derivate.
Selecția funcției se va realiza la rulare (late biding ,dynamic biding, runtime biding) Upcasting conversia
obiectelor claselor derivate către obiecte ale claselor de bază

Program :

#include <iostream>

#include <string.h>

Using namespace std;

Class Animal {

Protected:

Char nume [100];

Public:

Animal (char*nume )

{strcpy (this->nume,nume);}

Char *sunet ()

{return ''Nu știu '';}

Char get*getNume ()

{return nume;} };
Class pisica:public Animal {

Public :

Pisica (char*nume ):Animal (nume){ }

Char*sunet ()

{return ''Miau!'';} };

Class Caini :public Animal {

Public:

Caini (char*nume):Animal (nume){}

Char*sunet ()

{return ''Ham!!'';}

};

Int main ()

{Animal*a=new Animal (''Jerry'');

Pisica*t=new Pisica (''Tom'');

Caini *c=new Caini (''Azorel'');

Cout <<a->getNume ()<<'':''a->sunet ()<<endl;

Cout <<t->getNume ()<<'':''t->sunet ()<<endl;

Cout <<a->getNume ()<<'':''->sunet ()<<endl;

Cout <<c->getNume ()<<'':''c->sunet ()<<endl;

Cout <<a->getNume ()<<'':''->sunet ()<<endl;

Raspuns:

Jerry:''Nu stiu'' ;

Tom:''Miau'';

Azorel:''Ham'';

Tom:''Nu știu'';

Pointeri la clasa de bază :

Presupunem ca creem o joacă cu mai mulți jucători precum Ninja,Monștri etc.

Țoti vor avea în comun o funcție de atac totuși fiecare atac al fiecărui individ diferă.

Ninare lovitura sa de atac ,Monștrii al lor chiar daca au in comun un atribut (atacul) acesta lucrează
diferit pentru fiecare.
PPolimorfismul Îți permite sa creezi accea și funcție, in cazul nostru atacul asupra mai multor obiecte si
deoarece toate personajele sunt inamici ei deriva din aceiași clasa.

Apelind aceiași funcție cu obiecte diferite ei toți execută sarcinile lor.

Deci Polimorfismul Îți permite sa utilizezi aceiasi funcție dar rezultatele sa se difere.

Program:

#include <iostream>

Using namespace std;

Clase enemy {

Protected:

Int attackpower;

Public :

Void setAttackPower (int a)

{attackPower=a;

{classNinja:PublicEnemy {

Public:

Void attack ()

{cout <<''Im a ninja ninja chop! <<attackPower <<endl;

};

Class Monster:public Enemy {

Public:

Void attack()

{cout <<''Monster must eat you!!''<<attackPower<<endl;

};

Intmain {

Ninja n;

Monster m;

Enemy*enemy1=&n;

Enemy*enemy2=&n;
Enemy->setAttackPower(29);

Enemy->setAttackPower(40);

n.attack ();

m.attack ();

Răspuns :

I am,Ninja chap,-29

Monster must eat you,-40