OPERATORII DE DEREFERENŢIERE A POINTERILOR SPRE MEMBRII CLASELOR (.* sl ->*)
Asa cum s-a vazut în capitolul 20, în limbajul C++, operatorul unar & (operatorul adresa) se utilizeaza nu numai pentru a defini adresa operanzilor, ci si pentru a defini date de tip referinta, date care permit realizarea apelului prin referinta (call by reference). De aceea, în limbajul C++, operatorul unar & se mai numeste si operator de referentiere.
Operatorul unar * 828f54i (operatorul de indirectare) se aplica la un operand de tip pointer si el asigura accesul la data aflata în zona de memorie a carei adresa de început este valoarea operandului respectiv, în felul acesta operatorul unar * se poate considera ca are un efect invers operatorului unar &.
Exemplu:
int x;
int * p; // p este un pointer spre întregi de tip int
Fie:
p=&x;
Prin aceasta expresie, lui p i se atribuie adresa zonei de memorie alocata lui x. La valoarea lui x avem acces folosind fie numele x, fie expresia:
*P
formata din operandul p la care se aplica operatorul unar *.
Înlocuid pe p în expresia *p cu &x ajungem la concluzia ca expresia:
*&x
are aceeasi valoare ca si operandul x.
Operatorul unar * 828f54i , din expresia de mai sus, are un efect opus fata de operatorul unar &. El se mai numeste si operator de dereferentiere.
În limbajul C++ se pot defini pointeri spre elementele membru ale claselor, pointeri spre datele membru, precum si pointeri spre functiile membru ale claselor.
Pointerii spre elementele membru ale claselor se declara folosind numele clasei si operatorul de rezolutie.
Fie clasa cu numele nume_clasa care are o data membru de tip tip. Atunci pointerul p spre o data membru a clasei nume_clasa de tip tip, se declara astfel:
(1) tip nume_clasa::*p;
În mod analog, se definesc pointeri spre functiile membru ale clasei. Fie, de exemplu, o functie membru de prototip:
tip nume_clasa::nume_functie(lista tipurilor parametrilor formali);
Pointerul pf spre functia de acest prototip se declara astfel:
(2) tip(nume_clasa::*pf)(lista tipurilor parametrilor formali),
Aceste declaratii sunt analoge cu declaratiile de pointeri obisnuite. Diferenta dintre ele consta în aceea ca se utilizeaza numele clasei urmat de operatorul de rezolutie.
Pointerilor de acest tip li se atribuie valori ca mai jos.
Fie d o data membru a clasei nume_clasa de tip tip.
Atunci o expresie de forma:
(3) p = &nume_clasa::d
atribuie lui p adresa datei membru d.
În mod analog, pointerului pf i se atribuie o valoare folosind o expresie de forma:
(4) pf= nume_clasa::.nume_functie
unde:
nume_functie - Este o functie membru a clasei nume_clasa.
- Are prototipul indicat mai sus.
Expresiile (3) si (4) sînt acceptate în corpul functiilor membru ale clasei nume_clasa, precum si în orice parte a programului, daca elementele membru nu sunt protejate (d si nume_functie).
Pointerii p si pf se utilizeaza aplicând operatorii de dereferentiere ".*" si"->".
Ei se utilizeaza asemanator cu operatorii"." si "->".
Operatorul punct permite accesul la o componenta a unei date de un tip definit de utilizator. Numele datei structurate se afla în stânga punctului, iar numele componentei în dreapta lui.
În mod analog, în stânga operatorului ".*" se afla instantierea clasei (un obiect al clasei), iar în dreapta lui, în locul numelui componentei, se afla pointerul spre componenta respectiva.
De exemplu, expresia:
obiect*p
unde:
obiect - Este o instantiere a clasei:
nume_clasa adica nume_clasa obiect;.
p - Este pointerul declarat în (1) si la care i se atribuie o valoare prin expresia (3) permite acces la componenta:
obiect.d
unde:
d - Este o componenta a clasei nume_clasa.
Expresia (3) atribuie pointerului p deplasamentul componentei d, care stabileste pozitia ei în instantierile clasei nume_clasa.
Cu alte cuvinte, pointerul p declarat în (1) si la care i se atribuie o valoare prin expresia (3), permite înlocuirea expresiei:
obiect.d
cu
obiect.*p
În felul acesta, d este schimbat cu *p si apare ca o dereferentiere a pointerului p.
Operatorul "->*" se aplica atunci când în partea stânga se utilizeaza nu o instantiere a clasei (un obiect), ci un pointer spre tipul definit de clasa respectiva. Astfel, daca pobiect se declara ca un pointer spre tipul nume_clasa:
nume_clasa *pobiect,
atunci pointerul p declarat în (1) si la care i se atribuie valoare prin expresia (3), permite înlocuirea expresiei:
pobiect -> d
cu
pobiect ->*p
si în acest caz d apare ca o dereferentiere a pointerului p.
Operatorii ".*" si "->*" pot fi utilizati pentru a apela functii membru folosind declaratii de forma (2) si la care li se atribuie valori prin expresii de forma (4). Apelul:
obiect.nume_functie(...) unde:
obiect - Este o instantiere a clasei nume_clasa.
nume_functie - Este o functie membru a clasei nume_clasa de prototipul indicat mai sus; se poate exprima folosind pointerul pf astfel:
(obiect.*pf)(...)
În mod analog, apelul:
pobiect -> nume_functie(...) unde:
pobiect - Este un pointer spre nume_clasa, se poate exprima cu ajutorul pointerului pf astfel:
(pobiect ->*pf)(...)
În ambele cazuri, nume_functie este schimbat cu *pf si apare ca o
dereferentiere a pointerului pf.
Operatorii ".*" si "->*" au aceeasi prioritate care este imediat mai mica decât a operatorilor unari si imediat mai mare decât a operatorilor multiplicativi (/,*-binar si %). Ei se asociaza de la stânga la dreapta ca majoritatea operatorilor limbajului C++.
Operatorul ".*" nu poate fi supraîncarcat. Având în vedere acest fapt, lista completa a operatorilor care nu pot fi supraîncarcati este urmatoarea:
Exercitii:
26.1 Tipul complex se defineste mai jos cu urmatoarele functii membru:
- constructorul cu parametri impliciti;
- sum: însumeaza partile reale sau imaginare a doua obiecte;
- functii care supraîncarca operatorii binari + si -si operatorul unar minus;
- afiscomplex: afiseaza componentele unui obiect de tip complex;
- citdouble: citeste un numar de la intrarea standard;
- citcomplex: citeste componentele unui obiect de tip complex.
class complex ;
Mai jos, se definesc functiile membru si prieten ale clasei complex într-un fisier de extensie cpp.
#ifndef __STDIO_H
# include <stdio.h>
#define __STDIO_H
#endif
#ifndef __STDLIB_H
#include <stdlib.h>
#define__STDLIB_H
#endif
#ifndef __COMPLEX_H
#include"BXXVI1.H"
#define__COMPLEX_H
#endif
int complex::citdouble(char *text,double& d)
/* - afiseaza text;
- citeste un numar de la intrarea standard si-l pastreaza în zona referita de parametrul d;
- returneaza:
0 - la întâlnirea sfârsitului de fisier;
1 - altfel.
d=x;
return 1;
} // sfârsit citdouble
int complex::citcomplex()
/* - citeste componentele obiectului curent;
- returneaza:
0 - la întâlnirea sfârsitului de fisier;
1 - altfel. */
if (citdouble ( "Partea reala=" , real) ==0) return 0; //EOF
if (citdouble ( "Partea imaginara=" , imag) = = 0) return 0; //EOF
return 1;
inline void complex: :afiscomplex () const
// afiseaza componentele obiectului curent
inline void complex: : sum (complex ci, complex c2,
double complex: : *p)
/* - p pointeaza spre partea reala sau imaginara a obiectelor de tip complex;
partile obiectelor c1 si c2 spre care pointeaza p se însumeaza si se atribuie obiectului curent */
inline complex: : complex (double x, double y)
/* constructor utilizat la:
- initializarea obiectelor;
- conversia din tip predefinit în tip complex.
complex operator + (complex c1, complex c2) //returneaza c1+ c2
complex complex: : operator -() // returneaza negativul obiectului curen1
inline complex operator -(complex c1, complex c2) //returneaza c1 -c2
s.afiscomplex();
|
