Оператор области в Перегрузке Оператора - PullRequest
Новая
       6

Оператор области в Перегрузке Оператора

3 голосов
/ 19 сентября 2019

Я не могу понять оператор области действия при перегрузке оператора.Есть примеры, когда они используют это, когда они не делают.Когда я должен написать T::operator. Могу ли я написать только оператор по-прежнему работает нормально или рекомендуется использовать ::?

Пример:

Примеры прототипов (длякласс T) Внутри определения класса 

T& T::operator +=(const T2& b){}

Могу ли я написать это как T& operator +=(const T2& b){} Или я должен всегда писать это как T& T::operator +=(const T2& b){}

Ответы [ 2 ]

2 голосов
/ 19 сентября 2019

Оператор += может быть объявлен как функция-член или шаблон члена класса или шаблона класса и определен либо в классе, либо в шаблоне класса, либо вне их.

Если он определен вне классатогда требуется оператор области действия.

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

Рассмотрим следующую демонстрационную программу 

#include <iostream>

struct A
{
    int x = 0;

    A & operator +=( char c )
    {
        x += c;
        return *this;
    }
};

struct B
{
    int x = 0;

    B & operator +=( char c );
};

B & B::operator +=( char c )
{
    x += c;
    return *this;
}

struct C
{
    int x = 0;
};

C & operator +=( C & cls, char c )
{
    cls.x += c;

    return cls;
}

int main() 
{
    A a;

    a += 'A';

    std::cout << "a.x = " << a.x << '\n';

    B b;

    b += 'B';

    std::cout << "b.x = " << b.x << '\n';

    C c;

    c += 'C';

    std::cout << "c.x = " << c.x << '\n';

    return 0;
}

Его вывод 

a.x = 65
b.x = 66
c.x = 67

Оператор также может быть объявлен как оператор шаблона.Например, 

#include <iostream>

template <class T>
struct A
{
    T x = T();
};    

template <class T1, class T2>
T1 & operator +=( T1 &a, const T2 &x ) /* C++ 17 only requires requires( T1 t ) { t.x; }*/  
{
    a.x += x;
    return a;
}        

int main()
{

    A<int> a;
    std::cout << ( a += 10u ).x << '\n';
}

Опять же, если оператор является шаблоном функции-члена и определен вне его класса, то требуется оператор разрешения области.

#include <iostream>

template <class T1>
struct A
{
    T1 x = T1();
    template <class T2>
    A<T1> & operator +=( const T2 &x );
};    

template <class T1>
template <class T2>
A<T1> & A<T1>::operator +=( const T2 &x )
{
    this->x += x;
    return *this;
}        

int main()
{

    A<int> a;
    std::cout << ( a += 10u ).x << '\n';
}
2 голосов
/ 19 сентября 2019

Внутри класса вы не используете оператор разрешения области действия ::: 

class T {
public:
    // ...
    T operator+=(const T2& b)
    {
        // ...
    }
};

Если вы определяете оператор вне класса, то вы используете оператор разрешения области действия :: ввне определения класса.Вы все еще опускаете это в объявлении: 

class T {
public:
    // ...
    T operator+=(const T2& b);
};

// in the implementation
T T::operator+=(const T2& b)
{
    // ...
}

Это не имеет ничего общего с рекомендациями или хорошей практикой.Все изложенное здесь - единственный способ, который может работать, другие - просто неправильный код C ++.

...