Zadanie zespolone programowanie c++

Question

Polecenie:

Programowanie obiektowe

Zdefiniuj klasę liczb zespolonych tak, aby mogła zostać wykorzystana w poniższym programie i zapewnia poprawne wyniki obliczeń:

#include <iostream>
#include "complex0.h"

int main()
{
complex a(3.0, 4.0);  //inicjalizacja wartości (3, 4i)
complex c;
std::cout << "Podaj liczbę zespoloną (k, aby zakończyć):\n";
 
while(std::cin >>c)
{
std::cout << "c to  " << c << '\n';
std::cour << "sprężona z c to " << -c << '\n';
 std::cout << "a to  " << a << '\n';
std::cout << "a + c wynosi " << a + c << '\n';
std::cout << "a - c wynosi " << a - c << '\n';
std::cout << "a * c wynosi " << a * c << '\n';
std::cout << "2 * c wynosi " << 2 * c << '\n';
std::cout << "Podaj liczbę zespoloną (k, aby zakończyć):\n";
}
std::cout << "Gotowe\n";
return 0;
}

Zauważ, że trzeba będzie przeciążyc operator << i >>. Standard c++ ma już w nagłówku 'complex' wbudowaną obsługę liczb zespolonych (i to bardziej rozbudowaną niż w powyższym  przykładzie), więc aby uniknąc kolizji z biblioteką, zastosuj się dla pliku deklaracji klasy nazwę 'complex0.h'. Wszędzie tam, gdzie zasadne, stosuj modyfikacji 'const'.

Oto pożądany wynik programu:

Podaj liczbę zespoloną (k, aby zakończyć):
składowa rzeczywista: 10
składowa urojona: 12
c to (10, 12)
sprzężona z c to (-10, -12i)
a + c wynosi (13, 16)
a - c wynosi (-7, -8i)
a * c wynosi (-18 76i)
2 * c wynosi (20, 24)
Podaj liczbę zespoloną (k, aby zakończyć):
składowa rzeczywista: k
Gotowe

Zauważ, że przeciążona wersja operatora >> w wyrażeniu cin >> c powinna pytać o obie składowe (rzeczywistą i urojną) z osobna.

Próbowałem wykorzystać struktury zamieniając je na przeciążenia operatorów, jednak to spowodowało, że nie mam żadnego pomysłu na stworzenie odpowiedniego konstruktora zawierającego 2 operandy.

Proszę o podpowiedź jaki mógłby być uniwersalny kontruktor w programie, który mógłbym wykorzystać przy przeciążeniach.

Answer 1

Przykładowo prototypy mogą to wyglądać tak:

#include <iostream>

class Complex
{
public:
    Complex(double r = 0.0, double i = 0.0);
    ~Complex() = default;

    // metody przeciążające operatory
    Complex operator+(const Complex &) const;
    Complex operator-(const Complex &) const;
    Complex operator*(const Complex &) const;
    Complex operator*(double) const;
    Complex operator~() const;

    /* lub
    friend Complex operator+(const Complex &, const Complex &);
    friend Complex operator-(const Complex &, const Complex &);
    friend Complex operator*(const Complex &, const Complex &);
    friend Complex operator*(const Complex &, double);
    friend Complex operator~(const Complex &); */

    // funkcje zaprzyjaźnione
    friend Complex operator*(double n, const Complex &c) { return c * n; }
    friend std::istream &operator>>(std::istream &, Complex &);
    friend std::ostream &operator<<(std::ostream &, const Complex &);

private:
    double real;
    double imaginary;
};

Comments

Nie przypominam sobie po prostu, żebym się spotkał z takim warunkiem ale dziękuję za wytłumaczenie.

No właśnie i problem polega na tym, że pierwszy działa, nagle dwa ostatnie pokazały błąd:

W moim programie wygląda to tak (prototypy, ponieważ z nimi jest problem )

Complex operator*(const Complex & value) const;

friend Complex operator*(double d_value, const Complex & value) { return value * d_value; }

omplex0.h: In function ‘Complex operator*(double, const Complex&)’:

complex0.h:20:82: error: no match for ‘operator*’ (operand types are ‘const Complex’ and ‘double’)
   friend Complex operator*(double d_value, const Complex & value) { return value * d_value; }
                                                                                  ^
complex0.h:16:11: note: candidate: Complex Complex::operator*(const Complex&) const
   Complex operator*(const Complex & value) const;
           ^
complex0.h:16:11: note:   no known conversion for argument 1 from ‘double’ to ‘const Complex&’
complex0.h:20:18: note: candidate: Complex operator*(double, const Complex&)
   friend Complex operator*(double d_value, const Complex & value) { return value * d_value; }
                  ^
complex0.h:20:18: note:   no known conversion for argument 1 from ‘const Complex’ to ‘double’
In file included from main_zespolone.cpp:2:0:
complex0.h: In function ‘Complex operator*(double, const Complex&)’:
complex0.h:20:82: error: no match for ‘operator*’ (operand types are ‘const Complex’ and ‘double’)
   friend Complex operator*(double d_value, const Complex & value) { return value * d_value; }
                                                                                  ^
complex0.h:16:11: note: candidate: Complex Complex::operator*(const Complex&) const
   Complex operator*(const Complex & value) const;
           ^
complex0.h:16:11: note:   no known conversion for argument 1 from ‘double’ to ‘const Complex&’
complex0.h:20:18: note: candidate: Complex operator*(double, const Complex&)
   friend Complex operator*(double d_value, const Complex & value) { return value * d_value; }
                  ^
complex0.h:20:18: note:   no known conversion for argument 1 from ‘const Complex’ to ‘double’

 

---

Wklej resztę kodu, konstruktory wydają się dobre.

---

Zrobiłem to i podczas kompilacji pojawiają się błędy chociaż nie powinny. Sprawdziłem wiele możliwości problem leży w prototypach, chociaż pytanie dlaczego ?

---

Wklej swój cały kod to zobaczymy.

Konstruktory, które pisałem wcześniej są dobre, przykład poniżej:

// complex0.h -- definicja klasy Complex

#ifndef COMPLEX0_H
#define COMPLEX0_H

#include <iostream>

class Complex
{
public:
    Complex(double r = 0.0, double i = 0.0);
    ~Complex() = default;

    // metody przeciążające operatory
    Complex operator+(const Complex &) const;
    Complex operator-(const Complex &) const;
    Complex operator*(const Complex &) const;
    Complex operator*(double) const;
    Complex operator~() const;

    // funkcje zaprzyjaźnione
    friend Complex operator*(double n, const Complex &c) { return c * n; }
    friend std::istream &operator>>(std::istream &, Complex &);
    friend std::ostream &operator<<(std::ostream &, const Complex &);

private:
    double real;
    double imaginary;
};

#endif // COMPLEX0_H

// complex0.cpp -- implementacje klasy Complex

#include "complex0.h"

Complex::Complex(double r, double i)
{
    real = r;
    imaginary = i;
}

// metody przeciążające operatory
Complex Complex::operator+(const Complex &c) const
{
    return Complex(real + c.real, imaginary + c.imaginary);
}

Complex Complex::operator-(const Complex &c) const
{
    return Complex(real - c.real, imaginary - c.imaginary);
}

Complex Complex::operator*(const Complex &c) const
{
    return Complex((real * c.real - imaginary * c.imaginary), (real * c.imaginary + imaginary * c.real));
}

Complex Complex::operator*(double n) const
{
    return Complex(n * real, n * imaginary);
}

Complex Complex::operator~() const
{
    return Complex(real, -imaginary);
}

// funkcje zaprzyjaźnione
std::istream &operator>>(std::istream &is, Complex &c)
{
    std::cout << "Skladowa rzeczywista: ";
    is >> c.real;

    if (is)
    {
        std::cout << "Skladowa urojona: ";
        is >> c.imaginary;
    }

    return is;
}

std::ostream &operator<<(std::ostream &os, const Complex &c)
{
    os << "(" << c.real << ", " << c.imaginary << "i)";

    return os;
}

// main.cpp -- test klasy Complex, kompilować plikiem complex0.cpp

#include "complex0.h"
#include <iostream>

int main()
{
    Complex a(3.0, 4.0); // inicjalizacja wartością (3, 4i)
    Complex c;

    std::cout << "Podaj liczbe zespolona (k, aby zakonczyc)\n";

    while (std::cin >> c)
    {
        std::cout << "--\nc to " << c
                  << "\n# sprzezona z c to " << ~c
                  << "\n--\na to " << a
                  << "\n--\n# a + c wynosi " << a + c
                  << "\n# a - c wynosi " << a - c
                  << "\n# a * c wynosi " << a * c
                  << "\n# 2 * c wynosi " << 2 * c
                  << "\n# c * 2 wynosi " << c * 2
                  << "\n\nPodaj liczbe zespolona (k, aby zakonczyc)\n";
    }
    std::cout << "Gotowe!\n";

    return 0;
}

Jak nie chcesz wklejać swojego kodu, porównaj i przeanalizuj powyższy.

Kod kompiluje się bez błędów i liczy co powinien.

---

Wstawiłem dodatkowe przeciążenie i zaczęło działać. Dziękuję, bardzo mi pomogłeś.

Answer 2

struct complex
{
	double im;
	double re;

	complex() : im(), re() {}
	complex(double re_, double im_) 
		: re(re_), im(im_) {}
};

O to chodzi?

Comments

To jest struktura mi zależy na pomyśle stworzenia odpowiedniego Kontruktora:

Kontruktor(); //konstruktor domyślny # 1

complex c;

Chociaż ten też budzi lekki wątpliwości, ponieważ występuję poźniej przeciążenie operatora>> z udziałem tego obiektu.

Konstruktor(double A, double B); // kontruktor, który będzie wywoływany

complex a(3.0, 4.0);  //inicjalizacja wartości (3, 4i)

Po analizie wyniku programu mam spore zamieszanie, bo nigdy nie wykorzystywałem w ten sposób możliwości przeciążeń.

---

Nie wiem, może dziś nie kontaktuje, ale kompletnie nie rozumiem, o co Tobie chodzi. Przecież to, co podałem, pozwala na takie konstruowanie obiektów. Sprawdzałeś?

 

PS. w C++ struktura od klasy różni się jedynie domyślną dostępnością pól i metod.

---

Czy to jest dziedziczenie ":" ? Wybacz, ale nie doszedłem do tego etapu i nie rozumiem kodu wewnątrz struktury.

Chodzi o definicję kontruktora to już mam. Wybacz widocznie źle to opisałem.

---

Nie, to lista inicjalizacyjna konstruktora. Służy do nadawania wartości polom klasy.