Операторы c: Операторы в c и c++ — Википедия

Оценить статью:

Поделиться в социальных сетях:

выражения (Expressions) и операторы (Operators)

Выражение по сути является значением (выражает значение). Самый простой пример выражения — константа (например, 123) или переменная (например, x).Выражения можно объединять и изменять с помощью операторов. Операторы принимают один или более входящих операндов и возвращают новое выражение.

12 * 30 // * — оператор; 12 и 30 — операнды

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

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

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

Выражения, которые не возвращают никакого значения, называются пустыми выражениями (void expression), например, Console.WriteLine (1). Пустые выражения не могут быть использованы в качестве операнда в других (комплексных) выражениях.

Выражения присваивания (Assignment Expressions)

В выражениях присваивания используется оператор = позволяющий присвоить переменной значение другого выражения.

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

y = 5 * (x = 2) // y равен 10

Эта особенность может быть использована для инициализации нескольких переменных сразу:

Составные операторы присваивания (compound assignment operators) — сокращение, объединяющее присваивание с каким-либо другим оператором:

x *= 2 // аналог x = x * 2 x <<= 1 // аналог x = x << 1

Приоритет и ассоциативность операторов

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

Бинарные операторы (за исключением оператора присваивания =, лямбды => и оператора объединения со значением  Null ??) — лево-ассоциативные, т.е. выполняются слева направо (например, 8/4/2 выполняется как (8/4)/2). Порядок исполнения можно изменить с помощью скобок.

Оператор присваивания, лямбда, оператор объединения со значение Null и тернарный условный оператор — право-ассоциативные, т.е. исполняются справа налево.

Сводная таблица операторов C#

В следующей таблице операторы перечислены в порядке убывания их приоритета. Операторы расположенные под одним подзаголовком имеют одинаковый приоритет.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 T & operator = (T && other) noexcept // перемещаем присвоение
{
    if (this! = & other) {// запрет на самостоятельное присвоение (delete [] / size = 0 тоже нормально)
        удалить [] mArray; // удаляем это хранилище
        mArray = std :: exchange 

Приоритет оператора C ++ - cppreference.com

В следующей таблице перечислены приоритеты и ассоциативность операторов C ++. Операторы перечислены сверху вниз в порядке убывания приоритета.

1. ↑ Операнд sizeof не может быть приведением типа в стиле C: выражение sizeof (int) * p однозначно интерпретируется как (sizeof (int)) * p , но не sizeof ( (int) * p) .
2. ↑ Выражение в середине условного оператора (между ? и : ) анализируется так, как если бы оно заключено в круглые скобки: его приоритет относительно ?: игнорируется.

При синтаксическом анализе выражения оператор, который указан в некоторой строке приведенной выше таблицы с приоритетом, будет более жестко привязан (как если бы в круглые скобки) к своим аргументам, чем любой оператор, указанный в строке ниже, с меньшим приоритет. Например, выражения std :: cout << a & b и * p ++ анализируются как (std :: cout << a) & b и * (p ++), а не как std :: cout << (a & b ) или (* p) ++.

Операторы с одинаковым приоритетом привязываются к своим аргументам в направлении их ассоциативности.Например, выражение a = b = c анализируется как a = (b = c), а не как (a = b) = c из-за ассоциативности присваивания справа налево, а a + b - c анализируется (a + b) - c, а не a + (b - c) из-за ассоциативности слева направо сложения и вычитания.

Спецификация ассоциативности является избыточной для унарных операторов и показана только для полноты: унарные префиксные операторы всегда связываются справа налево (delete ++ * p - это delete (++ (* p))), а унарные постфиксные операторы всегда связывают левый -право (a [1] [2] ++ равно ((a [1]) [2]) ++).Обратите внимание, что ассоциативность имеет значение для операторов доступа к членам, даже если они сгруппированы с унарными постфиксными операторами: a.b ++ анализируется (a.b) ++, а не a. (B ++).

Приоритет оператора не зависит от перегрузки оператора. Например, std :: cout << a? до н.э; анализирует как (std :: cout << a)? до н.э; потому что приоритет арифметического сдвига влево выше, чем у условного оператора.

[править] Примечания

Приоритет и ассоциативность являются концепциями времени компиляции и не зависят от порядка оценки, который является концепцией времени выполнения.

Сам стандарт не определяет уровни приоритета. Они происходят из грамматики.

const_cast, static_cast, dynamic_cast, reinterpret_cast, typeid, sizeof ..., noexcept и alignof не включаются, поскольку они никогда не бывают неоднозначными.

Некоторые операторы имеют альтернативное написание (например, и для && , или для || , а не для ! и т. Д.).

В языке C тернарный условный оператор имеет более высокий приоритет, чем операторы присваивания.Следовательно, выражение e = a а << б
а >> б

! A
a && b
a || б

a == b
a! = B
a a> b
a <= b
a> = b
a <=> b

a [b]
* a
и a
a-> b
a.б
а -> * б
а. * б

а (...)
а, б
? :