C++
Перегрузка оператора

Вступление

замечания

Арифметические операторы

Вы можете перегрузить все основные арифметические операторы:

• + и +=
• - и -=
• * и *=
• / и /=
• & and &=
• | и |=
• ^ и ^=
• >> и >>=
• << и <<=

Перегрузка для всех операторов одинакова. Прокрутите вниз для объяснения

Перегрузка вне class / struct :

//operator+ should be implemented in terms of operator+=
T operator+(T lhs, const T& rhs)
{
    lhs += rhs;
    return lhs;
}

T& operator+=(T& lhs, const T& rhs)
{
    //Perform addition
    return lhs;
}

Перегрузка внутри class / struct :

//operator+ should be implemented in terms of operator+=
T operator+(const T& rhs)
{
    *this += rhs;
    return *this;
}

T& operator+=(const T& rhs)
{
    //Perform addition
    return *this;
}

Примечание: operator+ должен возвращаться неконстантным значением, поскольку возврат ссылки не имеет смысла (он возвращает новый объект) и не возвращает значение const (вы, как правило, не должны возвращать const ). Первый аргумент передается по значению, почему? Так как

1. Вы не можете изменить исходный объект ( Object foobar = foo + bar; не следует изменять foo конце концов, это не имеет смысла)
2. Вы не можете сделать его const , потому что вам нужно будет иметь возможность изменять объект (потому что operator+ реализован в терминах operator+= , который изменяет объект)

Передача const& будет вариантом, но тогда вам придется сделать временную копию переданного объекта. Переходя по значению, компилятор делает это за вас.

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

Первый аргумент - это ссылка (мы хотим ее изменить), но не const , потому что тогда вы не сможете ее изменить. Второй аргумент не должен быть изменен, поэтому аргумент производительности передается командой const& (передача по заданию const быстрее, чем по значению).

Унарные операторы

Вы можете перегрузить два унарных оператора:

• ++foo и foo++
• --foo и foo--

Перегрузка одинакова для обоих типов ( ++ и -- ). Прокрутите вниз для объяснения

Перегрузка вне class / struct :

//Prefix operator ++foo
T& operator++(T& lhs)
{
    //Perform addition
    return lhs;
}

//Postfix operator foo++ (int argument is used to separate pre- and postfix) 
//Should be implemented in terms of ++foo (prefix operator)
T operator++(T& lhs, int)
{
    T t(lhs);
    ++lhs;
    return t;
}

Перегрузка внутри class / struct :

//Prefix operator ++foo
T& operator++()
{
    //Perform addition
    return *this;
}

//Postfix operator foo++ (int argument is used to separate pre- and postfix) 
//Should be implemented in terms of ++foo (prefix operator)
T operator++(int)
{
    T t(*this);
    ++(*this);
    return t;
}

Примечание. Оператор префикса возвращает ссылку на себя, чтобы продолжить работу над ним. Первый аргумент - это ссылка, поскольку оператор префикса меняет объект, это также причина, по которой он не const (вы не смогли бы его изменить иначе).

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

Первый аргумент - это const ссылка на объект «вызов», потому что если он был const , вы не сможете его модифицировать, и если бы это не было ссылкой, вы не изменили бы исходное значение.

Это из-за копирования, необходимого для перегрузки операторов postfix, что лучше сделать привычкой использовать prefix ++ вместо postfix ++ in for циклов. С for точки контура, они , как правило , функционально эквивалентны, но может быть небольшое преимущество в производительности с использованием префикса ++, особенно с «тучные» классов с большим количеством участников для копирования. Пример использования префикса ++ в цикле for:

for (list<string>::const_iterator it = tokens.begin();
     it != tokens.end();
     ++it) { // Don't use it++
    ...
}

Операторы сравнения

Вы можете перегрузить все операторы сравнения:

• == и !=
• > и <
• >= и <=

Рекомендуемый способ перегрузить все эти операторы - это реализовать только 2 оператора ( == и < ), а затем использовать их для определения остальных. Прокрутите вниз для объяснения

Перегрузка вне class / struct :

//Only implement those 2
bool operator==(const T& lhs, const T& rhs) { /* Compare */ }
bool operator<(const T& lhs, const T& rhs) { /* Compare */ }

//Now you can define the rest
bool operator!=(const T& lhs, const T& rhs) { return !(lhs == rhs); }
bool operator>(const T& lhs, const T& rhs) { return rhs < lhs; }
bool operator<=(const T& lhs, const T& rhs) { return !(lhs > rhs); }
bool operator>=(const T& lhs, const T& rhs) { return !(lhs < rhs); }

Перегрузка внутри class / struct :

//Note that the functions are const, because if they are not const, you wouldn't be able
//to call them if the object is const

//Only implement those 2
bool operator==(const T& rhs) const { /* Compare */ }
bool operator<(const T& rhs) const { /* Compare */ }

//Now you can define the rest
bool operator!=(const T& rhs) const { return !(*this == rhs); }
bool operator>(const T& rhs) const { return rhs < *this; }
bool operator<=(const T& rhs) const { return !(*this > rhs); }
bool operator>=(const T& rhs) const { return !(*this < rhs); }

Операторы, очевидно, возвращают bool , указав true или false для соответствующей операции.

Все операторы принимают свои аргументы const& потому, что единственное, что делают операторы, - это сравнивать, поэтому они не должны изменять объекты. Проходя мимо & (ссылка) быстрее , чем по значению, и , чтобы убедиться , что операторы не изменяют его, это const -reference.

Обратите внимание, что операторы внутри class / struct определены как const , причина в том, что без функций const , сравнение объектов const будет невозможно, поскольку компилятор не знает, что операторы ничего не изменяют.

Операторы преобразования

Вы можете перегружать операторы типа, чтобы ваш тип мог быть неявно преобразован в указанный тип.

Оператор преобразования должен быть определен в class / struct :

operator T() const { /* return something */ }

Примечание: оператор const является const позволяющей преобразовывать объекты const .

Пример:

struct Text
{
    std::string text;

    // Now Text can be implicitly converted into a const char*
    /*explicit*/ operator const char*() const { return text.data(); }
    // ^^^^^^^
    // to disable implicit conversion
};

Text t;
t.text = "Hello world!";

//Ok
const char* copyoftext = t;

Оператор индексирования массива

Вы даже можете перегрузить оператор индексирования массива [] .

Вы всегда должны (99.98% времени) реализовывать 2 версии, версию const и not- const , потому что, если объект const , он не должен изменять объект, возвращенный [] .

Аргументы передаются const& вместо значения, потому что передача по ссылке быстрее, чем по значению, и const чтобы оператор не менял индекс случайно.

Операторы возвращаются по ссылке, потому что по дизайну вы можете изменить объект [] return, то есть:

std::vector<int> v{ 1 };
v[0] = 2; //Changes value of 1 to 2
          //wouldn't be possible if not returned by reference

Вы можете перегружать только внутри class / struct :

//I is the index type, normally an int
T& operator[](const I& index)
{
    //Do something
    //return something
}

//I is the index type, normally an int
const T& operator[](const I& index) const
{
    //Do something
    //return something
}

Множественные индексы, [][]... , могут быть достигнуты через прокси-объекты. Следующий пример простого строкового матричного класса демонстрирует следующее:

template<class T>
class matrix {
    // class enabling [][] overload to access matrix elements
    template <class C>
    class proxy_row_vector {
        using reference = decltype(std::declval<C>()[0]);
        using const_reference = decltype(std::declval<C const>()[0]);
    public:
        proxy_row_vector(C& _vec, std::size_t _r_ind, std::size_t _cols)
            : vec(_vec), row_index(_r_ind), cols(_cols) {}
        const_reference operator[](std::size_t _col_index) const {
            return vec[row_index*cols + _col_index];
        }
        reference operator[](std::size_t _col_index) {
            return vec[row_index*cols + _col_index];
        }
    private:
        C& vec;
        std::size_t row_index; // row index to access
        std::size_t cols; // number of columns in matrix
    };

    using const_proxy = proxy_row_vector<const std::vector<T>>;
    using proxy = proxy_row_vector<std::vector<T>>;
public:
    matrix() : mtx(), rows(0), cols(0) {}
    matrix(std::size_t _rows, std::size_t _cols)
        : mtx(_rows*_cols), rows(_rows), cols(_cols) {}

    // call operator[] followed by another [] call to access matrix elements
    const_proxy operator[](std::size_t _row_index) const {
        return const_proxy(mtx, _row_index, cols);
    }

    proxy operator[](std::size_t _row_index) {
        return proxy(mtx, _row_index, cols);
    }
private:
    std::vector<T> mtx;
    std::size_t rows;
    std::size_t cols;
};

Оператор вызова функции

Вы можете перегрузить оператор вызова функции () :

Перегрузка должна выполняться внутри class / struct :

//R -> Return type
//Types -> any different type
R operator()(Type name, Type2 name2, ...)
{
    //Do something
    //return something
}

//Use it like this (R is return type, a and b are variables)
R foo = object(a, b, ...);

Например:

struct Sum
{
    int operator()(int a, int b)
    {
        return a + b;
    }
};

//Create instance of struct
Sum sum;
int result = sum(1, 1); //result == 2

Оператор присваивания

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

Если вы не перегружаете оператор-ассистент для своего class / struct , он автоматически генерируется компилятором: автоматически созданный оператор присваивания выполняет «членное присвоение», то есть путем вызова операторов присваивания всем членам, так что один объект копируется другому, член в момент времени. Оператор присваивания должен быть перегружен, когда простое назначение по порядку не подходит для вашего class / struct , например, если вам нужно выполнить глубокую копию объекта.

Перегрузка оператора присваивания = легко, но вы должны выполнить несколько простых шагов.

1. Тест для самостоятельного назначения. Эта проверка важна по двум причинам:
   • самоназначение - это ненужная копия, поэтому нет смысла ее выполнять;
   • следующий шаг не будет работать в случае самоопределения.
2. Очистите старые данные. Старые данные должны быть заменены новыми. Теперь вы можете понять вторую причину предыдущего шага: если содержимое объекта было уничтожено, самоопределение не сможет выполнить копию.
3. Скопируйте всех участников. Если вы перегружаете оператор-ассистент для своего class или вашей struct , он не генерируется автоматически компилятором, поэтому вам нужно будет взять на себя ответственность за копирование всех членов из другого объекта.
4. Верните *this . Оператор возвращает себя по ссылке, потому что он позволяет связывать (т. int b = (a = 6) + 4; //b == 10 ).

//T is some type
T& operator=(const T& other)
{
    //Do something (like copying values)
    return *this;
}

Примечание: other передается const& потому, что назначаемый объект не должен быть изменен, а передача по ссылке быстрее, чем по значению, и чтобы убедиться, что operator= не модифицирует его случайно, это const .

Оператор присваивания может только быть перегружен в class / struct , так как слева значение = всегда class / struct сама по себе. Из-за этого определение этой функции как свободной функции не имеет этой гарантии.

Когда вы объявляете его в class / struct , левое значение неявно является самим class / struct , поэтому с этим не возникает никаких проблем.

Побитовый оператор NOT

Перегрузка побитового NOT ( ~ ) довольно проста. Прокрутите вниз для объяснения

Перегрузка вне class / struct :

T operator~(T lhs)
{
    //Do operation
    return lhs;
}

Перегрузка внутри class / struct :

T operator~()
{
    T t(*this);
    //Do operation
    return t;
}

Примечание: operator~ возвращает значение, потому что он должен возвращать новое значение (измененное значение), а не ссылку на значение (это будет ссылка на временный объект, который будет иметь значение мусора в нем, как только оператор выполнен). Не const потому что вызывающий код должен иметь возможность модифицировать его впоследствии (т. int a = ~a + 1; должно быть возможно).

Внутри class / struct вы должны сделать временный объект, потому что вы не можете изменить this , как бы изменить исходный объект, который не должен быть так.

Операторы сдвига битов для ввода / вывода

Операторы << и >> обычно используются как операторы «write» и «read»:

• std::ostream перегружает << для записи переменных в базовый поток (пример: std::cout )
• std::istream overloads >> читать из базового потока в переменную (пример: std::cin )

То, как они это делают, аналогично, если вы хотели перегрузить их «нормально» вне class / struct , за исключением того, что указание аргументов не одного типа:

• Тип возврата - это поток, который вы хотите перегрузить (например, std::ostream ), переданный по ссылке, чтобы обеспечить цепочку (Chaining: std::cout << a << b; ). Пример: std::ostream&
• lhs будет таким же, как тип возврата
• rhs типа вы хотите разрешить перегрузку из (т.е. T ), принятый const& вместо значения по причине производительности ( rhs не должны быть изменены в любом случае). Пример: const Vector& .

Пример:

//Overload std::ostream operator<< to allow output from Vector's
std::ostream& operator<<(std::ostream& lhs, const Vector& rhs)
{
    lhs << "x: " << rhs.x << " y: " << rhs.y << " z: " << rhs.z << '\n';
    return lhs;
}

Vector v = { 1, 2, 3};

//Now you can do
std::cout << v;

Сложные номера

В приведенном ниже коде реализована очень простая сложная тип номера, для которой автоматически создается базовое поле, следуя правилам продвижения типа языка, при применении четырех основных операторов (+, -, * и /) с членом другого поля (будь то другой complex<T> или некоторый скалярный тип).

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

#include <type_traits>

namespace not_std{

using std::decay_t;

//----------------------------------------------------------------
// complex< value_t >
//----------------------------------------------------------------

template<typename value_t>
struct complex
{
    value_t x;
    value_t y;

    complex &operator += (const value_t &x)
    {
        this->x += x;
        return *this;
    }
    complex &operator += (const complex &other)
    {
        this->x += other.x;
        this->y += other.y;
        return *this;
    }

    complex &operator -= (const value_t &x)
    {
        this->x -= x;
        return *this;
    }
    complex &operator -= (const complex &other)
    {
        this->x -= other.x;
        this->y -= other.y;
        return *this;
    }

    complex &operator *= (const value_t &s)
    {
        this->x *= s;
        this->y *= s;
        return *this;
    }
    complex &operator *= (const complex &other)
    {
        (*this) = (*this) * other;
        return *this;
    }

    complex &operator /= (const value_t &s)
    {
        this->x /= s;
        this->y /= s;
        return *this;
    }
    complex &operator /= (const complex &other)
    {
        (*this) = (*this) / other;
        return *this;
    }

    complex(const value_t &x, const value_t &y)
    : x{x}
    , y{y}
    {}

    template<typename other_value_t>
    explicit complex(const complex<other_value_t> &other)
    : x{static_cast<const value_t &>(other.x)}
    , y{static_cast<const value_t &>(other.y)}
    {}

    complex &operator = (const complex &) = default;
    complex &operator = (complex &&) = default;
    complex(const complex &) = default;
    complex(complex &&) = default;
    complex() = default;
};

// Absolute value squared
template<typename value_t>
value_t absqr(const complex<value_t> &z)
{ return z.x*z.x + z.y*z.y; }

//----------------------------------------------------------------
// operator - (negation)
//----------------------------------------------------------------

template<typename value_t>
complex<value_t> operator - (const complex<value_t> &z)
{ return {-z.x, -z.y}; }

//----------------------------------------------------------------
// operator +
//----------------------------------------------------------------

template<typename left_t,typename right_t>
auto operator + (const complex<left_t> &a, const complex<right_t> &b)
-> complex<decay_t<decltype(a.x + b.x)>>
{ return{a.x + b.x, a.y + b.y}; }

template<typename left_t,typename right_t>
auto operator + (const left_t &a, const complex<right_t> &b)
-> complex<decay_t<decltype(a + b.x)>>
{ return{a + b.x, b.y}; }

template<typename left_t,typename right_t>
auto operator + (const complex<left_t> &a, const right_t &b)
-> complex<decay_t<decltype(a.x + b)>>
{ return{a.x + b, a.y}; }

//----------------------------------------------------------------
// operator -
//----------------------------------------------------------------

template<typename left_t,typename right_t>
auto operator - (const complex<left_t> &a, const complex<right_t> &b)
-> complex<decay_t<decltype(a.x - b.x)>>
{ return{a.x - b.x, a.y - b.y}; }

template<typename left_t,typename right_t>
auto operator - (const left_t &a, const complex<right_t> &b)
-> complex<decay_t<decltype(a - b.x)>>
{ return{a - b.x, - b.y}; }

template<typename left_t,typename right_t>
auto operator - (const complex<left_t> &a, const right_t &b)
-> complex<decay_t<decltype(a.x - b)>>
{ return{a.x - b, a.y}; }

//----------------------------------------------------------------
// operator *
//----------------------------------------------------------------

template<typename left_t, typename right_t>
auto operator * (const complex<left_t> &a, const complex<right_t> &b)
-> complex<decay_t<decltype(a.x * b.x)>>
{
    return {
        a.x*b.x - a.y*b.y,
        a.x*b.y + a.y*b.x
        };
}

template<typename left_t, typename right_t>
auto operator * (const left_t &a, const complex<right_t> &b)
-> complex<decay_t<decltype(a * b.x)>>
{ return {a * b.x, a * b.y}; }

template<typename left_t, typename right_t>
auto operator * (const complex<left_t> &a, const right_t &b)
-> complex<decay_t<decltype(a.x * b)>>
{ return {a.x * b, a.y * b}; }

//----------------------------------------------------------------
// operator /
//----------------------------------------------------------------

template<typename left_t, typename right_t>
auto operator / (const complex<left_t> &a, const complex<right_t> &b)
-> complex<decay_t<decltype(a.x / b.x)>>
{
    const auto r = absqr(b);
    return {
        ( a.x*b.x + a.y*b.y) / r,
        (-a.x*b.y + a.y*b.x) / r
        };
}

template<typename left_t, typename right_t>
auto operator / (const left_t &a, const complex<right_t> &b)
-> complex<decay_t<decltype(a / b.x)>>
{
    const auto s = a/absqr(b);
    return {
         b.x * s,
        -b.y * s
        };
}

template<typename left_t, typename right_t>
auto operator / (const complex<left_t> &a, const right_t &b)
-> complex<decay_t<decltype(a.x / b)>>
{ return {a.x / b, a.y / b}; }

}// namespace not_std


int main(int argc, char **argv)
{
    using namespace not_std;

    complex<float> fz{4.0f, 1.0f};

    // makes a complex<double>
    auto dz = fz * 1.0;

    // still a complex<double>
    auto idz = 1.0f/dz;

    // also a complex<double>
    auto one = dz * idz;

    // a complex<double> again
    auto one_again = fz * idz;

    // Operator tests, just to make sure everything compiles.

    complex<float> a{1.0f, -2.0f};
    complex<double> b{3.0, -4.0};

    // All of these are complex<double>
    auto c0 = a + b;
    auto c1 = a - b;
    auto c2 = a * b;
    auto c3 = a / b;

    // All of these are complex<float>
    auto d0 = a + 1;
    auto d1 = 1 + a;
    auto d2 = a - 1;
    auto d3 = 1 - a;
    auto d4 = a * 1;
    auto d5 = 1 * a;
    auto d6 = a / 1;
    auto d7 = 1 / a;

    // All of these are complex<double>
    auto e0 = b + 1;
    auto e1 = 1 + b;
    auto e2 = b - 1;
    auto e3 = 1 - b;
    auto e4 = b * 1;
    auto e5 = 1 * b;
    auto e6 = b / 1;
    auto e7 = 1 / b;

    return 0;
}

Именованные операторы

Вы можете расширить C ++ с помощью именованных операторов, которые «цитируются» стандартными операторами C ++.

Сначала мы начинаем с десятичной библиотеки:

namespace named_operator {
  template<class D>struct make_operator{constexpr make_operator(){}};

  template<class T, char, class O> struct half_apply { T&& lhs; };

  template<class Lhs, class Op>
  half_apply<Lhs, '*', Op> operator*( Lhs&& lhs, make_operator<Op> ) {
    return {std::forward<Lhs>(lhs)};
  }

  template<class Lhs, class Op, class Rhs>
  auto operator*( half_apply<Lhs, '*', Op>&& lhs, Rhs&& rhs )
  -> decltype( named_invoke( std::forward<Lhs>(lhs.lhs), Op{}, std::forward<Rhs>(rhs) ) )
  {
    return named_invoke( std::forward<Lhs>(lhs.lhs), Op{}, std::forward<Rhs>(rhs) );
  }
}

это еще ничего не делает.

Во-первых, добавляющие векторы

namespace my_ns {
  struct append_t : named_operator::make_operator<append_t> {};
  constexpr append_t append{};
  
  template<class T, class A0, class A1>
  std::vector<T, A0> named_invoke( std::vector<T, A0> lhs, append_t, std::vector<T, A1> const& rhs ) {
      lhs.insert( lhs.end(), rhs.begin(), rhs.end() );
      return std::move(lhs);
  }
}
using my_ns::append;

std::vector<int> a {1,2,3};
std::vector<int> b {4,5,6};

auto c = a *append* b;

Ядро здесь состоит в том, что мы определяем объект append типа append_t:named_operator::make_operator<append_t> .

Затем мы перегружаем named_invoke (lhs, append_t, rhs) для типов, которые мы хотим, справа и слева.

Библиотека перегружает lhs*append_t , возвращая временный объект half_apply . Он также перегружает half_apply*rhs для вызова named_invoke( lhs, append_t, rhs ) .

Нам просто нужно создать правильный токен append_t и сделать ADL-friendly named_invoke соответствующей подписи, и все будет работать и работать.

Для более сложного примера предположим, что вы хотите иметь элементарное умножение элементов std :: array:

template<class=void, std::size_t...Is>
auto indexer( std::index_sequence<Is...> ) {
  return [](auto&& f) {
    return f( std::integral_constant<std::size_t, Is>{}... );
  };
}
template<std::size_t N>
auto indexer() { return indexer( std::make_index_sequence<N>{} ); }

namespace my_ns {
  struct e_times_t : named_operator::make_operator<e_times_t> {};
  constexpr e_times_t e_times{};

  template<class L, class R, std::size_t N,
    class Out=std::decay_t<decltype( std::declval<L const&>()*std::declval<R const&>() )>
  >
  std::array<Out, N> named_invoke( std::array<L, N> const& lhs, e_times_t, std::array<R, N> const& rhs ) {
    using result_type = std::array<Out, N>;
    auto index_over_N = indexer<N>();
    return index_over_N([&](auto...is)->result_type {
      return {{
        (lhs[is] * rhs[is])...
      }};
    });
  }
}

живой пример .

Этот элементный код массива может быть расширен для работы с кортежами или парами или массивами C-стиля или даже с контейнерами переменной длины, если вы решите, что делать, если длины не совпадают.

Вы также можете использовать тип элементарного типа и получить lhs *element_wise<'+'>* rhs .

Написание *dot* и *cross* продуктов также очевидны.

Использование * может быть расширено для поддержки других разделителей, таких как + . Прецизионность метрики определяет точность упомянутого оператора, что может быть важным при переводе физических уравнений на C ++ с минимальным использованием дополнительных () s.

С небольшим изменением в библиотеке выше мы можем поддерживать операторы ->*then* и расширять std::function до обновляемого стандарта или писать monadic ->*bind* . У него также может быть оператор с именем stateful, где мы тщательно передаем Op до последней функции invoke, разрешая:

named_operator<'*'> append = [](auto lhs, auto&& rhs) {
  using std::begin; using std::end;
  lhs.insert( end(lhs), begin(rhs), end(rhs) );
  return std::move(lhs);
};

создание именованного оператора контейнера-добавления в C ++ 17.