--> Archiwum Forum
CooN [ Generaďż˝ ]
Jest w tej chwili ktos obeznany w C++ (problem nie cierpiacy zwloki)?
Potrzebuje cos napisac "na wczoraj", stad natychmiastowa pomoc mile widziana. Jesli sie nie uda do jutra, to trudno.
Mam tutaj sytuacje wyjatkowa: konwersja typow
jest sobie taka funkcja, ktora dodaje liczby zespolone (cialo funkcji narazie niewazne):
zespol dodaj(zespol & l1, zespol & l2)
w programie wywoluje ja tak:
dodaj(liczba1,0.5); //liczba1 wczesniej zdefiniowana
dodaj(1.5,0.5);
Teoretycznie powinna zajsc konwersja float na istniejaca klase zespol. Nie zachodzi.
Kompilator protestuje. Dlaczego nie dziala?
Gdyby w funkcji dodaj usunac wysylanie przez referencje, to dziala poprawnie. Mi jednak zalezy na wysylaniu przez referencje.
Ishy [ Junior ]
Jesli do funkcji dane przekazywane sa przez referencje, to czemu przekazujesz do niej floata zamiast wskaznika na floata.
CooN [ Generaďż˝ ]
Nie przypuszczalem tak szybkiej reakcji!
Nie chodzi przeciez o to, by funkcje wywolywac ze wskaznikiem, np. dodaj(wsk1,wsk2), tylko podajac konkretne wartosci, np. dodaj(1.4,3.5).
soso [ Centurion ]
no coz... samo w programowaniu sie nic niezrobi :) a zwlaszcza konwersje (przynajmniej wiekszosc), niestety musisz przesiazyc funkcja na okolisczosc podawania floatow/doublow...
CooN [ Generaďż˝ ]
soso --> "samo w programowaniu sie nic nie zrobi" - no coz, czasem jednak moze sie zrobic, np. konstruktor kopiujacy :)
wracajac do sedna - chyba jednak musi byc jakis sposob bez przeladowania funkcji. Przeciez w tym sens konwersji. Czy ta glupia referencja musi psuc mi wieczor?! ;)
Plantator [ spamer ]
najprostszym sposobem jest zrobienie klasy zespolone oraz przeładowanie operatorów
Swidrygajłow [ ]
jak wygląda kontruktor klasy?
CooN [ Generaďż˝ ]
Plantator --> byc moze masz racje, przeladowaniem operatorow nie bawilem sie jeszcze.
Swidrygajłow --> zespol(float r, float i = 0): rzeczyw(r), urojon(i) ‹›
Swidrygajłow [ ]
ja tak to widzę:
no wiec tak, jesli argumentem jest float to kompilator korzystajac z konstruktora tworzy niejawnie obiekt typu zespol
jesli argumentem jest referencja nie moze tego zrobic, bo konstruktor nie przewiduje takiego typu argumentu
spróbuj przeładowac konstruktora klasy dla argumentu typu referencja do floata
CooN [ Generaďż˝ ]
Swidrygajłow --> czyli tak: zespol(float & r, float & i): rzeczyw(r), urojon(i) ‹› ?
Jesli to masz na mysli, to niestety nie dziala. Kompilator wciaz uparcie pisze:
could not convert `0x00000000000000000080fe3f0000000000000000' to `zespol&'
in passing argument 1 of `zespol dodaj(zespol&, zespol&)'
Swidrygajłow [ ]
ale musisz w tresci konstruktora obsłużyc referencje
CooN [ Generaďż˝ ]
A ma to jakies znaczenie? Zreszta i tak probowalem, ale moze popelaniam jakis blad. Gdyby nie sprawilo Ci klopotu, to moze napisalbys co masz na mysli?
Ode [ Centurion ]
rozumiem ze wczesniej zadeklarowałeś sobie taki typ zespol ? to jest struct czy co ??? skoro w kazdym razie masz cos takiego jak zespol to to co podajesz tez musi byc tego typu... mozesz napisac jak wygląda tego deklaracja ? albo po prostu spróbuj rzutowania typów ...
CooN [ Generaďż˝ ]
Ode --> naturalnie, ze sluze deklaracja, ba nawet definicja! ;)
class zespol‹
public:
float rzeczyw;
float urojon;
zespol(float r, float i = 0): rzeczyw(r), urojon(i) ‹›
void wypisz();
›;
gdzie ‹ to oczywiscie zawias klamrowy.
Zastanawialem sie (troche ciezko, bo wypilem juz nieco piwa ;) w jaki sposob mozna zrobic przeladowanie operatora, juz tutaj sugerowane. Nic konstruktywanego nie wymyslilem ;) (raczej nie chodzi o przeladowanie operatorow Plantator)
Plantator [ spamer ]
to nie wiem, ale przeładowanie operatorów i tak się przydaje ułatwia dokonywanie różnych obliczeń można pisać po prostu a+b zamiast dodaj(a,b)
CooN [ Generaďż˝ ]
Mam przeczucie, ze to cos, co sugerowal Swidrygajłow, ale on sie schowal i nie chce powiedziec ;)
Plantator [ spamer ]
mogę powiedzieć, że u mnie wyglądało to tak i raczej działało
class zespolone
‹
public:
double re, im;
zespolone(double r=0, double z=0):re(r),im(z) ‹› //konstruktor
double modul(zespolone b); //moduł
zespolone spzzz(zespolone b); //sprzężenie
zespolone operator+(zespolone b) //dodawanie
‹
static zespolone temp;
temp.re = re + b.re;
temp.im = im + b.im;
return temp;
›
zespolone operator-(zespolone b) //odejmowanie
‹
static zespolone temp;
temp.re = re - b.re;
temp.im = im - b.im;
return temp;
›
zespolone operator-() //liczba ujemna
‹
static zespolone temp;
temp.re = -re; temp.im = -im;
return temp;
›
zespolone operator*(zespolone b) //mnożenie
‹
static zespolone temp;
temp.re = re*b.re - im*b.im;
temp.im = re*b.im + b.re*im;
return temp;
›
zespolone operator/(zespolone b) //dzielenie
‹
static zespolone temp;
temp.re = ((re*b.re)/(b.re*b.re+b.im*b.im))+((im*b.im)/(b.re*b.re+b.im*b.im));
temp.im = ((-re*b.im)/(b.re*b.re+b.im*b.im))+((b.re*im)/(b.re*b.re+b.im*b.im));
return temp;
›
›;
double zespolone::modul(zespolone b)
‹ return sqrt(b.re*b.re + b.im*b.im); ›
zespolone zespolone::spzzz(zespolone b)
‹ b.im = -b.im; return b; ›
CooN [ Generaďż˝ ]
Dzien sie powoli konczy. Mimo, ze sie nie udalo zrobic tego, co chcialem, dziekuje wszystkim!
Swidrygajłow [ ]
przeładowujesz konstruktor, czyli masz odrebne konstruktory dla roznych typów argumentów
class zespol
<
float a, b;
zespol(float r, float i);
zespol(float *r, float *i);
>;
w konstruktorach obslugujesz argumenty
zespol::zespol(float r, float i)
<
a=r;
b=i;
>
zespol::zespol(float *r, float *i)
<
float &temp=(float &)r; // tu mogłem coś najebać, ale idea jest widoczna, tu zamineiasz referencje na float
this->a=temp;
temp=(float &)i;
this->b=temp;
>