1. Товары
2. Клиенты
3. Случаи использования

1. Переполнение стека Публичные вопросы и ответы
2. Команды Частные вопросы и ответы для вашей команды
3. предприятие Частные вопросы и ответы для вашего предприятия
4. работы Программирование и связанные с ним технические возможности карьерного роста
5. Талант Нанимать технический талант
6. реклама Связаться с разработчиками по всему миру

Загрузка…

2. Авторизоваться зарегистрироваться

sql — оператор IN для использования оператора AND

1. Товары
2. Клиенты
3. Случаи использования

1. Переполнение стека Публичные вопросы и ответы
2. Команды Частные вопросы и ответы для вашей команды
3. предприятие Частные вопросы и ответы для вашего предприятия
4. работы Программирование и связанные с ним технические возможности карьерного роста
5. Талант Нанимать технический талант

перегрузка оператора — cppreference.com

Настраивает операторы C ++ для операндов пользовательских типов.

[править] Синтаксис

Перегруженные операторы — это функции со специальными именами функций:

1) перегружен оператор;

[править] Перегруженные операторы

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

Примечание: для перегрузки co_await , (начиная с C ++ 20) пользовательские функции преобразования, пользовательские литералы, распределение и освобождение см. В соответствующих статьях.

Перегруженные операторы (но не встроенные операторы) можно вызывать с помощью функции обозначения:

 std :: string str = "Hello,";
str.operator + = ( "мир"); // так же, как str + = "world";
operator << (operator << (std :: cout, str), '\ n'); // так же, как std :: cout << str << '\ n';
                                               // (начиная с C ++ 17) за исключением последовательности 

[править] Ограничения

• Операторы :: (разрешение области), . (доступ к элементу), . * (доступ к элементу через указатель на элемент) и ?: (троичное условие) не могут быть перегружены.
• Новые операторы, такие как ** , <> или & | не может быть создан.
• Перегрузки операторов && и || теряют оценку короткого замыкания.
• Перегрузка оператора -> должна либо вернуть необработанный указатель, либо вернуть объект (по ссылке или по значению), для которого оператор -> в свою очередь перегружен.
• Невозможно изменить приоритет, группировку или количество операндов операторов.

[править] Канонические реализации

Кроме ограничений, описанных выше, язык не накладывает никаких других ограничений на то, что делают перегруженные операторы, или на тип возвращаемого значения (он не участвует в разрешении перегрузки), но в целом перегруженные операторы должны вести себя максимально схожими встроенные операторы: оператор + должен добавлять, а не умножать свои аргументы, оператор = должен назначать и т. д.Ожидается, что связанные операторы будут вести себя одинаково (оператор + и оператор + = выполняют одну и ту же операцию, подобную сложению). Типы возврата ограничены выражениями, в которых ожидается использование оператора: например, операторы присваивания возвращаются по ссылке, чтобы сделать возможным запись a = b = c = d, потому что встроенные операторы позволяют это.

Обычно перегруженные операторы имеют следующие типичные канонические формы: ^[1]

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

Оператор присваивания (operator =) обладает специальными свойствами: подробности см. В разделе «Копировать назначение» и «Переместить назначение».

Канонический оператор назначения копирования, как ожидается, не будет выполнять никаких действий по самопредставлению и вернет lhs по ссылке:

 // предположим, что объект содержит многократно используемую память, такую ​​как выделенный в куче буфер mArray
T & operator = (const T & other) // копировать назначение
{
    if (this! = & other) {// ожидается самопровозглашение
        if (other.size! = size) {// хранилище нельзя использовать повторно
            удалить [] mArray; // уничтожаем хранилище в этом
            размер = 0;
            mArray = nullptr; // сохранить инварианты на случай, если выбрасывается следующая строка
            mArray = new int [other.размер]; // создать хранилище в этом
            size = other.size;
        }
        std :: copy (other.mArray, other.mArray + other.size, mArray);
    }
    вернуть * это;
} 

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

 T & operator = (T && other) noexcept // перемещение назначения
{
    if (this! = & other) {// no-op при самостоятельном перемещении-назначении (delete [] / size = 0 тоже нормально)
        удалить [] mArray; // удаляем это хранилище
        mArray = std :: exchange (другое.mArray, nullptr); // оставить перемещенный из в правильном состоянии
        size = std :: exchange (other.size, 0);
    }
    вернуть * это;
} 

В тех ситуациях, когда назначение копии не может выиграть от повторного использования ресурса (он не управляет массивом, выделенным кучей, и не имеет (возможно, транзитивного) члена, который имеет, например, член std :: vector или std :: string), Существует популярное удобное сокращение: оператор присваивания «копировать-и-поменять», который принимает свой параметр по значению (таким образом, работая в качестве присваивания при копировании и перемещении в зависимости от категории значения аргумента), заменяет параметр и позволяет деструктор убери это.

 T & T :: operator = (T arg) noexcept // вызывается конструктор копирования / перемещения для создания аргумента
{
    std :: swap (size, arg.size); // ресурсы обмениваются между * this и arg
    std :: swap (mArray, arg.mArray);
    вернуть * это;
} // вызывается деструктор arg для освобождения ресурсов, ранее принадлежавших * this 

Эта форма автоматически предоставляет строгую гарантию исключений, но запрещает повторное использование ресурсов.

[править] Извлечение и вставка потока

Перегрузки операторов >> и оператора << , которые принимают std :: istream & или std :: ostream & в качестве левого аргумента, известны как операторы вставки и извлечения.Так как они принимают пользовательский тип в качестве правильного аргумента ( b в a @ b), они должны быть реализованы как не-члены.

 std :: ostream & operator << (std :: ostream & os, const T & obj)
{
    // записать объект в поток
    возврат ОС;
}
std :: istream & operator >> (std :: istream & is, T & obj)
{
    // читаем объект из потока
    если (/ * T не может быть построено * /)
        is.setstate (станд :: ИОС :: failbit);
    возврат есть;
} 

Эти операторы иногда реализуются как дружественные функции.

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

Когда определенный пользователем класс перегружает оператор вызова функции operator (), он становится типом FunctionObject.

Объект такого типа можно использовать в выражении, напоминающем вызов функции:

 // Объект этого типа представляет линейную функцию одной переменной a * x + b.
struct Linear {
    двойной а, б;

    двойной оператор () (double x) const {
        вернуть a * x + b;
    }
};
int main () {
    Линейный f {2, 1}; // Представляет функцию 2x + 1.Линейный г {-1, 0}; // Представляет функцию -x.
    // f и g являются объектами, которые можно использовать как функции.

    double f_0 = f (0);
    double f_1 = f (1);

    double g_0 = g (0);
} 

Ниже приведены две альтернативы такому подходу, которые не используют перегрузку, но имеют недостатки. 1. Использование глобальных переменных:

 двойной а, б; // Плохо: глобальные переменные.
двойной линейный (двойной х) {
    вернуть a * x + b;
}
int main () {
    а = 2; б = 1;
    double f_0 = linear (0);
    двойной f_1 = линейный (1);

    // Плохо: нужно переназначить параметры, чтобы можно было рассчитать другую функцию:
    а = -1; б = 0;
    double g_0 = linear (0);
} 

2.Используя дополнительные параметры:

 двойной линейный (двойной а, двойной б, двойной х) {
    вернуть a * x + b;
}
int main () {
    double f_0 = linear (2, 1, 0);
    // Плохо: придется повторить те же параметры снова:
    double f_1 = linear (2, 1, 1);

    double g_0 = linear (-1, 0, 0);
} 

Многие стандартные алгоритмы, от std :: sort до std :: аккумулирования, принимают FunctionObjects для настройки поведения. Нет особо заметных канонических форм operator (), но для иллюстрации использования

 struct Sum
{
    int sum;
    Sum (): sum (0) {}
    оператор void () (int n) {sum + = n; }
};
Sum s = std :: for_each (v.begin (), v.end (), Sum ()); 

См. Также лямбды.

[править] Увеличение и уменьшение

Когда постфиксный приращение и уменьшение появляются в выражении, соответствующая пользовательская функция (operator ++ или operator--) вызывается с целочисленным аргументом 0 . Как правило, он реализован как оператор T ++ (int), где аргумент игнорируется. Оператор увеличения и уменьшения постфикса обычно реализуется в терминах префиксной версии:

 struct X
{
    X & operator ++ ()
    {
        // здесь происходит фактический прирост
        вернуть * это;
    }
    Оператор X ++ (int)
    {
        X tmp (* это); // копировать
        Оператор ++ (); // предварительное увеличение
        возврат тмп; // вернуть старое значение
    }
}; 

Хотя каноническая форма предварительного увеличения / предварительного уменьшения возвращает ссылку, как и при любой перегрузке оператора, тип возвращаемого значения определяется пользователем; например, перегрузки этих операторов для std :: atomic возвращаются по значению.

[править] Бинарные арифметические операторы

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

 класс X
{
 общественности:
  X & operator + = (const X & rhs) // составное присваивание (не обязательно быть членом,
  {// но часто для изменения приватных членов)
    / * добавление rhs к * это происходит здесь * /
    вернуть * это; // вернуть результат по ссылке
  }

  // друзья, определенные внутри тела класса, встроены и скрыты от поиска без ADL
  Друг X оператор + (X lhs, // передача значения lhs по значению помогает оптимизировать цепочку a + b + c
                     const X & rhs) // в противном случае оба параметра могут быть константными ссылками
  {
    lhs + = rhs; // повторно использовать составное присваивание
    вернуть lhs; // возвращаем результат по значению (использует конструктор перемещения)
  }
}; 

[править] Реляционные операторы

Стандартные алгоритмы, такие как std :: sort, и контейнеры, такие как std :: set Ожидается, что оператор <будет определен по умолчанию для пользовательских типов и ожидает, что он реализует строгий слабый порядок (таким образом удовлетворяя требованиям сравнения).Идиоматический способ реализации строгого слабого упорядочения для структуры заключается в использовании лексикографического сравнения, предоставляемого std :: tie:

 struct Record
{
    std :: string name;
    без знака в пол;
    двойной вес;
    оператор bool друга <(const Record & l, const Record & r)
    {
        вернуть std :: tie (l.name, l.floor, l.weight)
             
 Как правило, после предоставления оператора <другие реляционные операторы реализуются в терминах оператора <.
 встроенный оператор bool <(const X & lhs, const X & rhs) {/ * выполнить фактическое сравнение * /}
оператор inline bool> (const X & lhs, const X & rhs) {return rhs  rhs); }
встроенный оператор bool> = (const X & lhs, const X & rhs) {return! (lhs 
 Аналогично, оператор неравенства обычно реализуется в терминах оператора ==:
 Встроенный оператор bool
 == (const X & lhs, const X & rhs) {/ * выполнить фактическое сравнение * /}
встроенный оператор bool! = (const X & lhs, const X & rhs) {return! (lhs == rhs); } 
 Если предусмотрено трехстороннее сравнение (например, std :: memcmp или std :: string :: compare), все шесть операторов связи могут быть выражены через это:
 встроенный оператор bool == (const X & lhs, const X & rhs) {return cmp (lhs, rhs) == 0; }
оператор inline bool! = (const X & lhs, const X & rhs) {return cmp (lhs, rhs)! = 0; }
встроенный оператор bool <(const X & lhs, const X & rhs) {return cmp (lhs, rhs) <0; }
встроенный оператор bool> (const X & lhs, const X & rhs) {return cmp (lhs, rhs)> 0; }
встроенный оператор bool <= (const X & lhs, const X & rhs) {return cmp (lhs, rhs) <= 0; }
встроенный оператор bool> = (const X & lhs, const X & rhs) {return cmp (lhs, rhs)> = 0; } 
 Оператор неравенства автоматически генерируется компилятором, если определен оператор ==.Аналогично, четыре реляционных оператора автоматически генерируются компилятором, если определен оператор трехстороннего сравнения <=>. operator == и operator <=>, в свою очередь, генерируются компилятором, если для оператора <=> задано значение по умолчанию:
 struct Record
{
    std :: string name;
    без знака в пол;
    двойной вес;
    авто оператор <=> (const Record &) = по умолчанию;
};
// записи теперь можно сравнивать с ==,! =, <, <=,> и> = 
 См. Сравнения по умолчанию для деталей.
.