Zaprojektuj własny typ Zespolone, tj. podaj odpowiednie struktury danych służące do przechowywania wartości tego typu, oraz nagłówki funkcji odpowiadających czterem standardowym operacjom arytmetycznym na liczbach zespolonych. Zaimplementuj dwie możliwe realizacje takich funkcji: w pierwszej funkcja zwraca wskaźnik do nowoutworzonego elementu tego typu; w drugiej funkcja modyfikuje drugi z argumentów.
Mógłby ktoś podpowiedzieć coś odnośnie pogrubionego fragmentu zadania? Nie czaje o co chodzi..
w pierwszej funkcja zwraca wskaźnik do nowoutworzonego elementu tego typu;
Zespolone* ZwracamWskaźnik(const Zespolone &a, const Zespolone &b);
w drugiej funkcja modyfikuje drugi z argumentów.
void ModyfikujęArgument(const Zespolone &a, Zespolone &b);
Ale ogólnie myślisz że powinno to wyglądać w ten sposób, że mam cztery funkcje, załóżmy
void dodawanie(zespolone rzeczywiste, zespolone urojone)
void odejmowanie(zespolone rzeczywiste, zespolone urojone)
void mnozenie(zespolone rzeczywiste, zespolone urojone)
void dzielenie(zespolone rzeczywiste zespolone urojone)
Teraz jako argumenty przekazuje adresy do zmiennych. A jeśli chodzi o te dwie funkcje, to tak:
pierwsza z nich wygląda w ten sposób, że najpierw tworzę sobie tą zmienną, natomiast funkcja zmienia poprzez wskaźniki wartości w tej zmiennej.
A druga... No właśnie nie rozumiem jak ma to wyglądać. Tzn. jeśli dodaję do siebie załóżmy dwie liczby zespolone, to jak mam zmieniać tylko drugi argument, sporo po dodania może być tak że zmieni się tylko część rzeczywista (pierwszy argument) a część urojona (drugi argument) pozostanie bez zmian.
Powinno to wyglądać tak, jak poradził Ci @Azarien
w pierwszej funkcja zwraca wskaźnik do nowoutworzonego elementu tego typu
Zespolone* dodawanie(Zespolone a, Zespolone b);
Zespolone* odejmowanie(Zespolone a,Zespolone b);
Zespolone* mnozenie(Zespolone a, Zespolone b);
Zespolone* dzielenie(Zespolone a, Zespolone b);
w drugiej funkcja modyfikuje drugi z argumentów
void dodawanie(const Zespolone& a, Zespolone& b);
void odejmowanie(const Zespolone& a, Zespolone&b);
void mnozenie(const Zespolone&a, Zespolone&b);
void dzielenie(const Zespolone&a, Zespolone&b);
Np, tak :https://ideone.com/lZIREV
Dobra dzięki Wam, wieczorkiem będę kombinował :)
EDIT. Siedzę nad tym, ale nie rozumiem tego:
Zespolone* dodawanie(Zespolone a, Zespolone b);
No bo załóżmy, że mamy coś takiego:
int *w
jest to wskaźnik o nazwie w który wskazuje na zmienną typu int.
Tak więc jak rozumieć taki zapis?
Zespolone* dodawanie(Zespolone a, Zespolone b);
Ja rozumiem go tak, iż jest to wskaźnik którego nazwą jest to co zwróci funkcja i wskazuje on na zmienną typu Zespolone... Przecież to nie ma sensu.
@Florian
Źle kombinujesz.
Tak więc jak rozumieć taki zapis?
Zespolone* dodawanie(Zespolone a, Zespolone b);
Ja rozumiem go tak, iż jest to wskaźnik którego nazwą jest to co zwróci funkcja i wskazuje on na zmienną typu Zespolone... Przecież to nie ma sensu.
Nope, jest to funkcja zwracająca wskaźnik na obiekt( czyli de facto nowy obiekt ), który jest tworzony w owej funkcji.
Oczywiście poźniej należy zwolnić pamięć.
dodanie znacznika <code class="cpp"> - @furious programming
Nie umiem sobie wyobrazić jak ma np wyglądać ta funkcja dodawania, co ona ma zwracać żeby to wszystko pasowało do tego wskaźnika...
Mógłbyś ją jakoś pokazać w pseudokodzie?
Hmm, nie wiem jak taką dość trywialną czynność w pseudokod ująć ale spróbuje.
Zespolona, i przypisujesz do niego adres nowo utworzonej zmiennej.Zespolona* dodaj1(const Zespolona& a, const Zespolona& b)
{
// nieco uproszczone;
// tworzysz nowy obiekt Zespolona
// i dodajesz sobie
Zespolona* _tmp = new Zespolona(a.re+b.re, a.im+b.im); //1 oraz 2
return _tmp; // 3
}
// edit, już rozumiesz?
No kurde nie potrafię sobie z tym poradzić... mam taki kod:
#include <iostream>
using namespace std;
enum typdzialania {
DODAWANIE = 1,
ODEJMOWANIE = 2,
MNOZENIE = 3,
DZIELENIE = 4
};
typedef struct Zespolone {
int rzeczywista;
int urojona;
};
void wczytywanie()
{
Zespolone liczba1,liczba2;
typdzialania typ;
int p;
cout << "Podaj pierwsza liczbe zespolona:" << endl;
cout << "Czesc rzeczywista: ";
cin >> liczba1.rzeczywista;
cout << endl << "Czesc urojona: ";
cin >> liczba1.urojona;
cout << "Podaj druga liczbe zespolona: " << endl;
cout << "Czesc rzeczywista: ";
cin >> liczba2.rzeczywista;
cout << endl << "Czesc urojona: "
cin >> liczba2.urojona;
cout << endl << "Wybierz rodzaj dzialania:" << endl;
cout << "1 - DODAWANIE" << endl << "2 - ODEJMOWANIE" << endl;
cout << "3 - MNOZENIE" << endl << "4 - DZIELENIE" << endl;
cin << p;
if (p==1) typ=DODAWANIE;
if (p==2) typ=ODEJMOWANIE;
if (p==3) typ=MNOZENIE;
if (p==4) typ=DZIELENIE;
switch (typ)
{
case DODAWANIE:
break;
case ODEJMOWANIE:
break;
case MNOZENIE:
break;
case DZIELENIE:
break;
}
}
Chciałbym do tego dorzucić teraz funkcję dodawania. Według podpowiedzi powinna ona wyglądać mniej więcej (raczej mniej) w ten sposób:
Zespolone *dodawanie(Zespolone liczba1, Zespolone liczba2)
{
Zespolone *zmienna;
zmienna = new Zespolone(liczba1.rzeczywista+liczba2.rzeczywista, liczba1.urojona+liczba2.urojona);
return zmienna;
}
no ale chyba nie do końca?
Powinna wyglądać dokładnie tak.
funkcja dodawanie(...) dodaje i tworzy nowy obiekt.
//edit
coś takiego : https://ideone.com/yUsDjk
Wywala mi jeden błąd, jak sobie z tym poradzić?
cannot convert 'int*' to 'Zespolone*' in assignment
No eeej.
Ale pomyśl troche (Dostałeś niemalże gotowca).
Próbujesz przypisać do ptra Zespolone wskaźnik na inta.
Sorka że tak Cię tutaj mocno wykorzystuję :P
Możesz napisać dlaczego wywala mi błąd w tej linii z gwiazdkami
#include <iostream>
using namespace std;
enum typdzialania {
DODAWANIE = 1,
ODEJMOWANIE = 2,
MNOZENIE = 3,
DZIELENIE = 4
};
typedef struct Zespolone {
int rzeczywista;
int urojona;
};
Zespolone *dodawanie(Zespolone liczba1, Zespolone liczba2)
{
Zespolone *zmienna;
zmienna = new Zespolone(liczba1.rzeczywista+liczba2.rzeczywista, liczba1.urojona+liczba2.urojona);*****************************************
return zmienna;
}
void wczytywanie()
{
Zespolone liczba1,liczba2;
Zespolone *wynik = NULL;
typdzialania typ;
int p;
cout << "Podaj pierwsza liczbe zespolona:" << endl;
cout << "Czesc rzeczywista: ";
cin >> liczba1.rzeczywista;
cout << endl << "Czesc urojona: ";
cin >> liczba1.urojona;
cout << "Podaj druga liczbe zespolona: " << endl;
cout << "Czesc rzeczywista: ";
cin >> liczba2.rzeczywista;
cout << endl << "Czesc urojona: ";
cin >> liczba2.urojona;
cout << endl << "Wybierz rodzaj dzialania:" << endl;
cout << "1 - DODAWANIE" << endl << "2 - ODEJMOWANIE" << endl;
cout << "3 - MNOZENIE" << endl << "4 - DZIELENIE" << endl;
cin >> p;
if (p==1) typ=DODAWANIE;
if (p==2) typ=ODEJMOWANIE;
if (p==3) typ=MNOZENIE;
if (p==4) typ=DZIELENIE;
switch (typ)
{
case DODAWANIE:
wynik = dodawanie(liczba1,liczba2);
break;
case ODEJMOWANIE:
break;
case MNOZENIE:
break;
case DZIELENIE:
break;
}
cout << wynik << endl;
delete wynik;
}
Pewnie jest coś nie tak z typami, ale za bardzo nie wiem c zmienić...
Ktoś zakładał, że zaprojektowałes odpowiednią strukturę danych - czyli w tym wypadku klasę i że jest tam konstruktor odpowiedniego typu, czyli z argumentami zmienna_rzeczywista i zmienna_urojona
w struct Zespolone brakuje konstruktora, magicznie to sie nie wypełni
typedef jest tam nie potrzebny, nie programujesz w C.
cout << wynik << endl; to bzdura, musiałbyś przeciążyć operator <<
cytując @Shalom Moc copy-paste jest w tobie silna młody padawanie :D
Jeśli w C++, to konstruktor możesz dodać w strukturze, a jeśli jednak to ma być w C, to musisz mieć funkcję na zasadzie:
struct Zespolone *TworzZespolone( int arzeczywista, int aurojona)
{
struct Zespolone *res = malloc(sizeof(struct Zespolone));
if (res)
{
res->rzeczywista = arzeczywista;
res->urojona = aurojona;
}
return res;
}
analogicznie wtedy należy stworzyć destruktor.