Conversiile sunt executate automat daca:
a) operanzii nu sunt de acelasi tip (char, enum int double, , iar la atribuire se face conversia valoarii expresiei in tipul variabilei);
b) parametrul actual nu are tipul parametrului formal (se face conversia primului);
c) tipul valorii returna 333c21d te de o functie difera de tipul acesteia (se face conversia valorii).
Conversiile dintre un tip predefinit si un tip abstract se pot realiza printr-un constructor care sa contina un parametru avand acel tip predefinit, iar ceilalti vor fi initializati.
Exemplu
// Numere rationale: Q
#include <string.h>; #include <iostream.h>; #include <conio.h>;
long Cmmdc(long, long);
class Q ;
inline Q::Q(long p=0, long q=1 )
Q& Q::operator ~()
Q operator *(Q r, Q s) friend
inline void Q::Tip (const char* Mes)
long Cmmdc(long a, long b)
;
void main ()
Rezultate:
x : 3/2
y : 2/9
z : 2/1
x*y = 1/3
w : 2/1
x*w = 3/1
x*2 = 3/1
2*x = 3/1
O alta varianta in care se evita utilizarea unei functii prietene este de a defini o functie membru (Produs) care se va apela de catre functia de supraincarcare a operatorului de inmultire.
Exemplu
// Numere rationale: Q
#include <string.h>; #include <iostream.h>; #include <conio.h>;
long Cmmdc(long, long);
class Q ;
inline Q::Q(long p=0, long q=1 )
Q& Q::operator ~()
inline Q Q::Produs (Q r)
Q operator (Q p, Q q) operator de inmultire
inline void Q::Tip (const char* Mes)
long Cmmdc(long a, long b)
void main ()
Rezultate:
x : 3/2
y : 2/9
z : 4/2
x*y= 1/3
x*z= 3/1
x*2= 3/1
2*x= 3/1
O alta problema pe care o vom aborda in cele ce urmeaza este de a realiza o conversie dintr-un tip abstract in altul. Pentru aceasta vom defini un constructor pentru realizarea conversiei dorite.
In programul urmator am definit tipul complex in cele doua forme:
a) algebrica - clasa C,
b) trigonometrica (polara) - clasa T.
Conversia realizata face trecerea din forma b) in forma a).
Pentru a putea verifica rezultatele, se utilizeaza si tipul complex predefinit.
Exemplu:
// Numere complexe: T C
#include <iostream.h> #include <conio.h> #include <math.h>
#include <complex.h>
// class C;
class T ;
class C ;
C::C ( float a, float b )
C::C (T z) // Conversie prin constructor C<-T
float C::Modul( )
float C::Arg ( )
float C::Arg ( )
void C::Tip ( const char* Mesaj)
T::T ( float Modul, float Arg)
// T::T (C w) // Conversie C->T
float T::Re ( )
float T::Im ( )
void T::Tip(const char* Mesaj)
void main ()
Rezultate:
(r,u)=2,3;
(a,b)= -1.979985+0.28224i
z =(-1.979985,0.28224)
(x,y)= -1.979985+0.28224i
(r,u)=2,3;
Conversia dintr-un tip abstract de data intr-un tip predefinit se poate realiza prin supraincarcarea operatorului de conversie explicita corespunzator, printr-o functie membru definita astfel:
class Clasa
Clasa :: operator Tip_Predefinit ( )
In exemplul urmator se va realiza o conversie dintr-un numar rational intr-un numar real:
// Conversie Tad-Q double
#include <string.h>; #include <iostream.h>; #include <conio.h>;
class Q ;
inline Q::Q(long p, long q)
inline Q::operator double ()
inline Q Q::operator * (Q r)
inline void Q::Tip(const char* Mes)
void main ()
Rezultate:
z = 6/35
a = 1.8
b = 1.8
Acest tip de conversie se poate realiza si prin oparatori (dar nu simultan si prin constructori). In programul urmator este realizata conversia (prin operatorul de conversie) din trigonometrica (clasa T) in forma algebrica (clasa C):
// Numere complexe: T C
#include <iostream.h> #include <conio.h> #include <math.h>
#include <complex.h>
class C ;
C::C ( float a, float b )
float C::Modul( )
float C::Arg ( )
void C::Tip ( const char* Mesaj)
class T ;
T::T ( float Modul, float Arg)
T::operator C() // Op. Conv.
float T::Re ( )
float T::Im ( )
void T::Tip (const char* Mesaj)
void main ()
Rezultate:
(r,u)=2,3;
(a,b)= -1.979985+0.28224i
z =(-1.979985,0.28224)
|
