Pointeri la clase

Odata declarata, clasa devine un tip valid., astfel poate fi folosita ca tip indicat printr-un pointer.:
Rectangle * prect; //

Este un pointer la un obiect al clasei Rectangle.

Membrii unui obiect pot fi accesati direct dintr-un pointer utilizind operatorul (->).
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// pointer to classes example

#include <iostream>
using namespace std;
class Rectangle {
int width, height;
public:
Rectangle(int x, int y) : width(x), height(y) {}
int area(void) { return width * height; }
};
int main() {
Rectangle obj (3, 4);
Rectangle * foo, * bar, * baz;
foo = &obj;
bar = new Rectangle (5, 6);
baz = new Rectangle[2] { {2,5}, {3,6} };
cout << "obj's area: " << obj.area() << '\n';
cout << "*foo's area: " << foo->area() << '\n';
cout << "*bar's area: " << bar->area() << '\n';
cout << "baz[0]'s area:" << baz[0].area() << '\n';
cout << "baz[1]'s area:" << baz[1].area() << '\n';
delete bar;
delete[] baz;
return 0;
}

Interpretarea operatorilor:
expresia

Poate fi citit ca
pointerul x
&x
Adresa lui x
x.y
membrul y al obiectului x
x->y
member y of object pointed to by x
(*x).y member y of object pointed to by x (equivalent to the previous one)
x[0]
first object pointed to by x
x[1]
second object pointed to by x
x[n]
(n+1)th object pointed to by x
*x

Supraincarcarea operatorilor
Rezulattul adunarii a doi vectori cartezieni (3,1) si (1,2) va fi (3+1,1+2) = (4,3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// overloading operators example

#include <iostream>
using namespace std;
class CVector {
public:
int x,y;
CVector () {};
CVector (int a,int b) : x(a), y(b) {}
CVector operator + (const CVector&);
};
CVector CVector::operator+ (const CVector& param) {
Rezultat: 4,3
CVector temp;
temp.x = x + param.x;
temp.y = y + param.y;
return temp;
}
int main () {
CVector foo (3,1);
CVector bar (1,2);
CVector result;
result = foo + bar;
cout << result.x << ',' << result.y << '\n';
return 0;
}

Pointerul this
Pointerul this este un pointer la obiect. Este folosit la functia membrului clasei care se refera la obiectul
dat.
// example on this
#include <iostream>
using namespace std;
class Dummy {
public:
bool isitme (Dummy& param);
};
bool Dummy::isitme (Dummy& param)
{
Rezultat: yes, &a is b
if (&param == this) return true;
else return false;
}
int main () {
Dummy a;
Dummy* b = &a;
if ( b->isitme(a) )
cout << "yes, &a is b\n";
return 0;
}

Membrii statici
// static members in classes
#include <iostream>
using namespace std;
class Dummy {
public:
static int n;
Dummy () { n++; };
};
int Dummy::n=0;
int main () {
Dummy a;
Dummy b[5];
cout << a.n << '\n';
Dummy * c = new Dummy;
cout << Dummy::n << '\n';
delete c;
return 0;
}

Rezultat:
6
7

Supraincarcarea operatorilor speciali

1) Sa se realizeze un program care creeaza o anumita clasa putere, ce calculeaza rezultatul dat de ridicarea
unui numar la o putere (presupunem exponentul puterii un ntreg pozitiv), folosind pointerul this.
#include <iostream>
using namespace std;
#include<conio.h>
class putere
{
double b;
int e;
double val;
public:
putere(double baza, int exp);
double calculeaza() {return this->val ;}
};
putere::putere(double baza, int exp)
{
this->b=baza;
this->e=exp;
this->val=1;
if(exp==0) return;
for(;exp>0;exp--)
this->val=this->val*this->b;
}
main()
{
putere x(3,4);
putere y(2.5,1);
putere z(5.7,0);
cout<<x.calculeaza()<<endl;
cout<<y.calculeaza()<<endl;
cout<<z.calculeaza()<<endl;
getch();
}

2) Folosindu-se o clasa cu membrii: un vector de 3 elemente, iniaializat printr-un constructor sa se

implementeze operatorul de indexare. Se cere a se efectua o indexare sigura a unei marice, in caz
contrar, se cere parasirea programului.
#include <iostream>
using namespace std;
#include<conio.h>
#include<stdlib.h>
class index{
int a[3];
public:
index(int i,int j,int k)
{
a[0]=i;
a[1]=j;
a[2]=k;
}
int& operator[](int i);
};
int& index::operator[](int i)
{
if(i<0 || i>2)
{
cout<<endl<<"Eroare la limita."<<'\n';
exit(1);
}
return a[i];
}
main()
{
index ob(1,2,3);
for(int i=0;i<3;i++)
cout<<ob[i]<<endl;
ob[2]=25; //aceasta atribuire este posibila doar datorita valorii
returnate ca referinta
cout<<ob[2];
getch();
ob[3]=30;
}

3) Sa se realizeze un program care foloseste supraincarcarea operatorului "=".

#include <iostream>
using namespace std;
#include<conio.h>
#include<string.h>
class sir
{
char* a;
public:
//constructor
sir (char b[]);
//constructor de copiere
sir (sir &x);
void operator=(sir &x);
void afis(char *);
};
inline sir::sir(char b[])
{
a=new char[strlen(b)+1];
strcpy(a,b);
}
inline sir::sir(sir &x)
{
a=new char[strlen(x.a)+1];
strcpy(a,x.a);
}
void sir::operator=(sir& x)
{
delete a;
a=new char[strlen(x.a)+1];
strcpy(a,x.a);
}
void sir::afis(char *z)
{
cout<<"Sirul "<<z<<" este: "<<a<<endl;
}
main()
{
sir a("un sir ");
cout<<"Dati un sir dorit: ";
char s[256];
cin.getline(s,sizeof(s),'\n');
sir b(s);
sir c=a;
a.afis("a");
b.afis("b");
c.afis("c");
a=b;
a.afis("a");
b.afis("b");
getch();}