Все операторы C ++, с которыми я работал, что-то возвращают, например + оператор возвращает результат сложения.

Все ли операторы C ++ что-то возвращают, или есть некоторые операторы C ++, которые ничего не возвращают?

Нет, не все операторы что-то возвращают.

Хотя они, вероятно, не совсем то, о чем вы думаете, обратите внимание, что ключевые слова deleteи delete[]C ++ на самом деле являются операторами ; и они определены как имеющие voidвозвращаемый тип - что означает, что они ничего не оценивают (что не является «чем-то»).

Из cppreference :

void operator delete  ( void* ptr ) noexcept;
void operator delete[]( void* ptr ) noexcept;

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

например, оператор + возвращает результат сложения.

Не обязательно:

#include <iostream>
struct foo {
    int value = 0;
    void operator+(int x) {
        value += x;
    }
};

int main () {
    foo f;
    f + 3;
}

Здесь operator+к valueчлену добавляется левая часть , и его возвращаемый тип недействителен. Это выдуманный пример, но, в целом, отсутствие возврата чего-либо из пользовательского оператора не является чем-то необычным.

Единственный оператор, который может быть перегружен и который требует возврата чего-либо, о чем я знаю, - это operator->. Он должен возвращать необработанный указатель или объект с расширением operator->.

К мелочам операторы ничего не возвращают. Это просто лексические элементы, которые мы используем для создания выражений в языке. Теперь выражения имеют типы и могут оцениваться в значения, и я предполагаю, что это то, что вы подразумеваете под операторами, «возвращающими вещи».

И, ну да. Существуют выражения C ++ с типом void(и, следовательно, не имеют никакого значения). Некоторые из них очевидны, другие - менее. Хорошим примером будет

throw std::runtime_error()

throwэто выражение согласно грамматике C ++. Вы можете использовать его в других выражениях, например, в условном выражении

return goodStatus() ? getValue() : throw std::runtime_error();

А тип выражения throw - void. Очевидно, поскольку это просто приводит к быстрому перемещению выполнения в другое место, выражение не имеет значения.

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

Скорее, все операторы что-то оценивают . У этого чего-то есть четко определенное значение, а также тип . Даже оператор вызова функции void operator()(/*params*/)является voidтипом.

Например, +'a'это intтип со значением, 'a'закодированным на вашей платформе.

Если ваш вопрос: «Могут ли операторы C ++ иметь voidвозвращаемый тип?» тогда ответ, безусловно, да.

Фактически вы можете определить оператор вызова функции, чтобы ничего не возвращать. Например:

struct Task {
   void operator()() const;
};

operator void (): определяемая пользователем функция преобразования в void

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

#include <iostream>

struct Foo {
    operator void() { std::cout << "Foo::operator void()!"; }
    // warning: conversion function converting 'Foo' to 
    //          'void' will never be used
};
    
int main() {
    Foo f;
    (void)f;            // nothing
    f.operator void();  // Foo::operator void()!
}

в соответствии с [class.conv.fct] / 1

[...] Функция преобразования никогда не используется для преобразования объекта (возможно, квалифицированного cv) в (возможно, квалифицированный cv) объект того же типа (или ссылку на него) в базовый класс (возможно, квалифицированный cv) такого типа (или ссылку на него), или к (возможно , CV-квалифицированным) void. ¹¹⁷

^{( 117 )} Эти преобразования рассматриваются как стандартные преобразования в целях разрешения перегрузки ([over.best.ics], [over.ics.ref]) и, следовательно, инициализации ([dcl.init]) и явного приведения типов. Преобразование в voidне вызывает никаких функций преобразования ([expr.static.cast]). Даже если они никогда не вызываются напрямую для выполнения преобразования, такие функции преобразования могут быть объявлены и потенциально могут быть достигнуты через вызов функции виртуального преобразования в базовом классе.

Однако, хотя, как показано выше, вы все равно можете вызывать его, используя явный .operator void()синтаксис.

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

• арифметика (+, -, *, /)
• приращение / уменьшение (++, -)
• присвоение (=, + =, - =, * =, / =,% =, >> =, << =, & =, ^ =, | =)
• логика (!, &&, ||)
• реляционные (==,! =,>, <,> =, <=)
• условно?
• запятая

и так далее. Список может быть очень обширным.

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

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

С другой стороны, перегруженные операторы могут быть определены с возвращаемым значением некоторого типа, даже если оно может быть недействительным, поэтому нет, не все операторы возвращают какое-либо значение в C ++.

Я предполагаю, что вы говорите о операторных функциях, а не об операторах как синтаксической единице языка.

Если вы перегружаете операторы любого типа, вы можете вернуть все, что захотите.

Это также имеет большой смысл, потому что такие операции, как * или (), иногда могут интуитивно не возвращать свой тип ввода. Представьте себе умножение типа комплексного числа на тип действительного числа. Или оператор, возвращающий элемент из коллекции.

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

Нет. Рассмотрим эти два примера здесь:

int multiply (int a, int b) {
   return a*b;
}

void multiply_void(int a, int b) {
   cout << a*b;
//or cout << multiply(a,b);
}

Первая функция вернет целочисленное значение, которое может использоваться другой функцией. Значение возвращается и сохраняется в памяти для использования при необходимости. В противном случае он не виден человеку и просто радостно хранится в памяти.

Вторая функция будет выводить на устройство вывода по умолчанию (обычно консоль). Значение, возвращаемое оператором умножения, передается на устройство вывода. Функция multiply_void не возвращает фактического значения.

Все операторы что-то возвращают. Их называют операторами, потому что они чем-то управляют, поэтому они что-то возвращают. Те Операторы, которые что-то не возвращают, не могут называться операторами. Либо они вернут какое-то значение, либо вернут True или False в зависимости от ситуации.

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

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

• Перегруженный оператор, который преобразуется в вызов функции.

• оператор new, который вызывается как часть выражения new , является вызовом функции.

Моя единственная цель при упоминании вызовов функций - уточнить результат по сравнению с возвратом. Если посмотреть на все 126 экземпляров «return» и слова, производные от него в [expr] , в этом разделе, кажется, тщательно используется слово return для обозначения:

• результат вызова функции

• аспекты потока управления, связанные с сопрограммами

Ладно, хватит педантизма по поводу результата и возврата.

Операторы C ++ возвращают что-то или нет, зависит от того, как вы их использовали. Встроенные операторы C ++ возвращают некоторое значение до тех пор, пока не будут принудительно возвращены void.