Оператор перегружает комплексные номера - дополнительная функция

Question

Я пытаюсь понять идею перегрузки оператора, я догадываюсь о том, когда все это собирается, и я мог бы повесить его, но ...

Я изо всех сил пытаюсь понять часть кода, в которой используется оператор +, который был перегружен, так что он будет добавлять сложные номера, код довольно прост.

#include <iostream> 

using namespace std; 


class complex { 
    protected: 
    double Re, Im; 

public: 
    complex() : Re(0.0), Im(0.0) {} 
    complex(double Re, double Im) : Re(Re), Im(Im) {} 
    double getRe() const { return Re; } 
    double getIm() const { return Im; } 
    friend complex operator+(const complex&, const complex&); 
    friend ostream& operator<<(ostream&, const complex&); 
}; 

complex operator+(const complex& a, const complex& b) { 
double r, i; 
r = a.getRe() + b.getRe(); 
i = a.getIm() + b.getIm(); 
**return complex(r, i);** // *** CAN ANYONE EXPLAIN THIS BIT ? *** 
} 

ostream& operator<<(ostream& out, const complex &a) { 
    out << "(" << a.getRe() << ", " << a.getIm() << ")" << endl; 
    return out; 
} 

int main(void) { 
    complex a(1,2), b(3,4), c; 
    c = a+b; 
    cout << c << endl; 

}

Я не могу понять, что именно линия 23 делает:

return complex(r, i); 

Перегруженный оператор добавления должен возвращать некоторое значение, так как было выяснено, что должно быть значение сложный тип.

Чтобы он выглядел как объявленный в сложном классе, , но имеет ли он какое-то отношение к конструктору?

Я имею в виду, как теперь будет компилятор, как выглядит тип «сложный», поскольку это имя класса, связано ли это с конструктором класса?

Создают ли конструкторы значения, являющиеся типом класса?

Например, у нас есть класс холодной собаки.

значение, которое будет тип класса называется собака, будет выглядеть так:

значение собаки

ли конструктор в классе собаки определяет определение стоимости, как это выглядит, какая информация он хранит?

2. Как я могу перегрузить оператор ostream >> (cin), чтобы пользователь мог указать собственные значения комплексных чисел?

Спасибо!

Answer 1

комментарий вписан

complex operator+(const complex& a, const complex& b) { 
double r, i; 
r = a.getRe() + b.getRe(); // real part of the result 
i = a.getIm() + b.getIm(); // imaginary part of the result 
return complex(r, i); // you are returning (by value) a complex number formed from r and i 
} 

здесь, комплекс (г, г) создает временный сложный объект (вызов конструктора для инициализации) и возвращают значение создаст еще один временный использовать в вызывающей программе.

Перегрузки >> объявят как

friend istream& operator >> (istream&, complex&); 

и определяют как:

istream& operator >> (istream& i, complex& c) { 
    i >> c.Re >> c.Im; 
    return i; 
} 

Answer 2

перегрузка Оператора не имеет ничего общего с конструктором (ни по умолчанию, ни скопировать или переместить конструкторы, а результаты могут быть скопированы, хотя в зависимости от подписи).

В основном вы говорите компьютеру, как применять определенный оператор/операцию к объектам вашего класса (или любой комбинации с другими значениями в зависимости от доступных параметров).

Так как это работает?

Pretty simple. Давайте предположим, что компилятор находит конструкцию, например, как это:

result = first + second; 

В этом примере мы получили два оператора, так что по сути два шага:

• operator+() с first и second.
• operator=() (оператор присваивания (если определено) или конструктор копирования), чтобы назначить result.

Так что компилятор знает, что нужно будет найти соответствие operator+() подписи на основе типов first и second. Есть два основных способа это может быть определено:

• Либо в качестве члена класса first «s: ... FirstClass::operator+(const SecondClass &secondObject) (мой предпочтительный способ)
• или как отдельную функцию с двумя аргументами: ... operator+(const FirstClass &firstObject, const SecondClass &secondObject) (единственный способ сделать это для классов, которые вы не можете обновить, например, тех, которые находятся в стандартной библиотеке (std namespace)).

Я опустил типы возврата, так как они действительно зависят от вас. Несмотря на то, что это не рекомендуется, вы можете вернуться почти ко всему, вам даже не нужно «добавлять», например, с помощью operator+().

В вашем примере с комплексными числами компилятор будет искать ... complex::operator+(const complex &other), ... operator+(const complex &left, const complex &right) или любые варианты совместимых операторов, которые могут использоваться с неявным литьем.

---

Для второй части Вашего вопроса с участием someInputStream >> myComplexNumber - Как реализовать недостающий оператор?

Поскольку у вас нет прямого доступа для изменения класса входного потока (независимо от его действительности), вам придется определить его вне класса с двумя параметрами. Применяя знания выше становится довольно тривиально:

std::istream &operator>>(std::istream &input, complex &number); 

Первое краткое объяснение, почему ссылки в параметрах не const: Вы должны изменить их обоих. Это противоречит типичному математическому соглашению, например. при оценке c = a + b, вы не будете изменять ни a, ни b. Хотя это звучит странно, это как есть. Для потока это связано с изменением потока (даже если вы только перемещаете указатель на текущую позицию в вашем потоке). Что касается комплексного числа, это связано с выполнением задания.

Тип возврата в этой ситуации должен быть istream &, потому что вам нужно снова вернуть объект потока. Это согласуется. Теоретически (как упоминалось выше) вам не нужно будет этого делать, но тем самым вы реализуете ожидаемое поведение, которое позволяет пользователю привязать этих операторов к чтению нескольких вещей, например.что-то вроде myStream >> complex1 >> complex2; (это по существу оценивается до myStream >> complex1; и myStream >> complex2).

После того, как у вас есть подпись вашей функции, вы просто должны заполнить содержимое, что опять-таки тривиально сделать:

std::istream &operator>>(std::istream &input, complex &number) { 
    input >> number.Re >> number.Im; // query the real and imaginary parts one after the other as doubles (since that's the members' type) 
    return input; // return the stream again 
} 

Если у вас есть вопросы, понимая это (довольно основной) концепции, попробуйте иметь в виду, что операторы - это просто удобный способ записи этих перегруженных функций. Вместо использования + вы также можете использовать operator+().

Следующие две строки, по существу, одно и то же:

complexResult = complexNumber1 + complexNumber2; 
complexResult = operator+(complexNumber1, complexNumber2); 

То же самое верно и для других операторов, как >>, ||, & и т.д.

Answer 3

#include <iostream> 
using namespace std; 
class complex 
{ private : 
int real ; 
int imag ; 
public : 
complex(int real=0 , int imag=0) 
{ 
    this->real=real; 
    this->imag=imag; 
} 

complex operator +(complex ob2) 
{ complex ob3; 
    ob3.real=real + (ob2.real); 
    ob3.imag=imag + (ob2.imag); 
    return ob3; } 
void out() 
{ cout<<real<<" + "<<imag<<"i"<<endl;} 
}; 
int main() 
{ 
int real_1,imag_1; 
int real_2,imag_2; 
cout<<"real part Enter ";cin>>real_1; 
cout<<"imaginary part Enter ";cin>>imag_1; 
complex ob(real_1,imag_1); 
cout<<"real part Enter ";cin>>real_2; 
cout<<"imaginary part Enter ";cin>>imag_2; 
complex ob2(real_2,imag_2); 
complex ans; 
ans=ob+ob2; 
    ans.out();` ` 
}