Обобщенные классы в С++

[like-nix]

И то что я написал это не перегрузка =)
перегрузка оператора+ будет выглядеть так:

template <class  T>
inline complex2<T> complex2<T>::operator+ (int  rkV) const
{
    return complex2<T>(
        this->a + rkV,
        this->b + rkV);
}

[ACE Valery]

Объяснение

кривое какое-то объяснение.. То есть я имею в виду, что мой браузер эту штуку отображает криво: во-первых, код там написан только до собственно перегрузки =, а выводимые результаты вообще не скроллятся. И по этой причине никакого объяснения я там не нашла.
Поэтому, раз уж вы берете на себя задачу ответить на вопрос, который я задала An1ka, то ответьте, пожалуйста словами.

[like-nix]

2ACE Valery
Приношу извинения, не учел что у когото может не открыться страница, которая у меня открыватся в firefox opera chrome.

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

#include <iostream>

template <class T>
 class complex
{
public:
    complex()
    {
        std::cout << "construct complex" << std::endl;
    }
    complex(const complex& c)
    {
        a = c.a;
        b = c.b;
        std::cout << "construct complex" << std::endl;
    }
   T a, b;
   complex operator +( complex ob1); // функция перегрузки оператора сложения
   complex operator =( complex ob1); // функция перегрузки оператора присвоения

};

template <class T>
 complex<T> complex< T>::operator +( complex ob1) // функция перегрузки оператора сложения
{
  complex<T> c;
  c.a = ob1.a + this->a;
  c.b = ob1.b + this->b;
return c;
}

template <class T>
 complex<T> complex< T>::operator =( complex ob1) // функция перегрузки оператора присвоения
{
  a = ob1.a;
  b = ob1.b;
return ob1;
}

 template <class T>
 class complex2
{
public:
    complex2()
    {
        std::cout << "construct complex2" << std::endl;
    }
    complex2(const complex2& c)
    {
        a = c.a;
        b = c.b;
        std::cout << "construct complex2" << std::endl;
    }
    complex2(const T& t1, const T& t2):a(t1),b(t2){}
   T a, b;
   complex2 operator+ (const complex2& rkV) const; // функция перегрузки оператора сложения
   complex2& operator= (const complex2&); // функция перегрузки оператора присвоения
    bool operator== (const complex2&) const;

};

template <class T>
inline complex2<T>& complex2<T>::operator= (const complex2& rkV)
{
     if(*this == rkV ) return *this;
     this->a = rkV.a;
     this->b = rkV.b;
    return *this;
}

template <class  T>
inline complex2<T> complex2<T>::operator+ (const complex2& rkV) const
{
    return complex2<T>(
        this->a + rkV.a,
        this->b + rkV.b);
}

template <class T>
bool complex2<T>::operator== (const complex2& rkV) const
{
    return this->a == rkV.a && this->b == rkV.b? true: false;
}
int main(void)
{
    std::cout << "==begin ini complex<int> first, second, result" << std::endl;
   complex<int> first, second, result;
    std::cout << "==begin ini complex<int> first, second, result" << std::endl;

   first.a =1;
   first.b =3;
   second.a =5;
   second.b =7;

    std::cout << "==begin result = first + second + second + second + second" << std::endl;
    result = first + second + second + second + second;
    std::cout << "==end result = first + second + second + second + second" << std::endl;

    first.a =1;
   first.b =3;
   second.a =5;
   second.b =7;
    result.a = 45;
    result.b = 65;

    std::cout << "==begin result = first = second" << std::endl;
   result = first = second;
    std::cout << "==end result = first = second" << std::endl;

    std::cout << "==begin ini complex2<int> first2, second2, result2" << std::endl;
   complex2<int> first2, second2, result2;
    std::cout << "==end ini complex2<int> first2, second2, result2" << std::endl;

    first2.a =1;
   first2.b =3;
   second2.a =5;
   second2.b =7;

    std::cout << "==begin result2 = first2 + second2 + second2 + second2 + second2" << std::endl;
    result2 = first2 + second2 + second2 + second2 + second2;
    std::cout << "==end result2= first2 + second2 + second2 + second2 + second2" << std::endl;

    first2.a =1;
   first2.b =3;
   second2.a =5;
   second2.b =7;

    std::cout << "==begin result2 = first = second" << std::endl;
   result2 = first2 = second2;
    std::cout << "==end result2 = first = second" << std::endl;
    
    
    return 0;
}

результат работы

==begin ini complex<int> first, second, result
construct complex
construct complex
construct complex
==begin ini complex<int> first, second, result
==begin result = first + second + second + second + second
construct complex
construct complex
construct complex
construct complex
construct complex
construct complex
construct complex
construct complex
construct complex
==end result = first + second + second + second + second
==begin result = first = second
construct complex
construct complex
construct complex
==end result = first = second
==begin ini complex2<int> first2, second2, result2
construct complex2
construct complex2
construct complex2
==end ini complex2<int> first2, second2, result2
==begin result2 = first2 + second2 + second2 + second2 + second2
==end result2= first2 + second2 + second2 + second2 + second2
==begin result2 = first = second
==end result2 = first = second

[like-nix]

>код там написан только до собственно перегрузки =
ммм там нет перегрузки ^^

[Obey-Kun]

template <class T>
inline complex2<T>& complex2<T>:perator= (const complex2& rkV)
{
if(*this == rkV ) return *this;
this->a = rkV.a;
this->b = rkV.b;
return *this;
}

Проверка if(*this == complex ) будет запускаться всегда, а срабатывать редко. Так что в целом производительность будет ниже. Лучше от этой строки избавиться.

[like-nix]

2Obey-Kun
только в этом случае могу согласиться с этим. Так как если класс содержит структуры данных, которые имеют собственные механизмы проверки намного более оптимизированные чем присваивание, то эта строка поможет. А в данном случае не так важно.

[like-nix]

И разница(более менее ощутимая в долях секунды) будет заметна только в на какой то там милионной операции. В данном случае

[Obey-Kun]

И разница(более менее ощутимая в долях секунды) будет заметна только в на какой то там милионной операции. В данном случае

Ну это да, естественно всё зависит от того, что именно мы хотим от софтины. Просто сейчас оптимизирую свою программу, там подобные незначительные вещи заметно ухудшали отзывчивость гуя (не сказать, что значительно, но заметно).

[like-nix]

Дело в том что я всетаки сделал ошибку =))))) И Obey-Kun ее заметил(почти), потому что на самом деле должны сравниваться указатели, для того чтобы исключить присваивание самому себе)). Я в суматохе на ваял код и не заметил что я пишу бред).

Вот нормальный код.

template <class T>
inline complex2<T>& complex2<T>::operator= (const complex2& rkV)
{
     if(this == &rkV ) return *this;
     this->a = rkV.a;
     this->b = rkV.b;
    return *this;
}

оператор == теперь не нужен.

[Obey-Kun]

Ой а я вообще не о том говорил ну ты понял. зато теперь ошибки нет. но всё равно можно без этой строки обойтись. Так как лучше немного времени потерять, если мы пытаемся делать a=a, но не терять нисколько, если мы делаем a=b.