Другие операторы

Объяснение

Оператор вызова функции предоставляет семантику функции для любого объекта.

Условный оператор (в разговорной речи — тройной условный) проверяет булево значение первого выражения и, в зависимости от результата, вычисляет и возвращает либо второе, либо третье выражение.

Встроенный оператор вызова функции

Выражения вызова функции имеют вид

где

• функция — выражение типа функции или указателя на функцию, и
• арг1, арг2, арг3,... — возможно пустой список произвольных выраженийили списки инициализации в фигурных скобках(с C++11), за исключением оператора запятой на верхнем уровне, чтобы избежать неоднозначности.

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

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

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

Для вызова функции,

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

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

Если функция является функцией с переменным числом аргументов, преобразования по умолчанию применяются ко всем аргументам, соответствующим параметру эллипса. Определяется ли срок жизни параметра по завершении функции, в которой он определен, или по завершении содержащего его выражения — зависит от реализации.

Тип возвращаемого значения выражения вызова функции — это тип возвращаемого значения выбранной функции, определённый с помощью статического связывания (игнорируя ключевое слово virtual), даже если переопределяющая функция, которая фактически вызывается, возвращает другой тип. Это позволяет переопределяющим функциям возвращать указатели или ссылки на классы, которые производятся от типа возвращаемого значения базовой функции, т. е. C++ поддерживает ковариантные типы возвращаемых значений. Если функция указывает на деструктор, тип возвращаемого значения — void.

Категория значения выражения вызова функции — lvalue, если функция возвращает ссылку на lvalue или ссылку на rvalue на функцию; xvalue, если функция возвращает ссылку на rvalue на объект; и prvalue в противном случае. Если выражение вызова функции является prvalue типа объекта, оно должно иметь полный тип, за исключением случаев, когда prvalue не материализуется, таких как(с C++17) использование его в качестве операнда decltype (или в качестве правого операнда встроенного оператора запятой, который является операндом decltype).

Выражение вызова функции аналогично по синтаксису инициализации значения T(), выражению приведения типа в стиле функции T(A1), и прямой инициализации временного объекта T(A1, A2, A3, ...), где T — имя типа.

#include <cstdio>
 
struct S
{
    int f1(double d)
    {
        return printf("%f \n", d); // variable argument function call
    }
 
    int f2()
    {
        return f1(7); // member function call, same as this->f1()
                      // integer argument converted to double
    }
};
 
void f()
{
    puts("function called"); // function call
}
 
int main()
{
    f();    // function call
    S s;
    s.f2(); // member function call
}

function called
7.000000

Встроенный оператор запятой

Выражения оператора запятой имеют вид

В выражении с оператором запятой E1, E2, выражение E1 вычисляется, его результат игнорируется (хотя, если у него есть тип класса, он не будет уничтожен до конца содержащего его полного выражения), а его побочные эффекты завершаются до начала вычисления выражения E2 (обратите внимание, что пользовательский operator, не может гарантировать порядок)(до C++17).

Тип, значение и категория значения результата выражения с оператором запятой — это тип, значение и категория значения второго операнда E2. Если E2 — временное выражение(с C++17), результат выражения — это временное выражение(с C++17). Если E2 — битовое поле, результат — битовое поле.

Запятая в различных списках, разделяемых запятыми, таких как списки аргументов функций (f(a, b, c)) и списки инициализаторов int a[] = {1, 2, 3}, не является оператором запятой. Если в таких контекстах требуется использовать оператор запятой, его необходимо заключить в скобки: f(a, (n++, n + b), c).

#include <iostream>
 
int main()
{
    // comma is often used to execute more than one expression
    // where the language grammar allows only one expression:
 
    // * in the third component of the for loop
    for (int i = 0, j = 10; i <= j; ++i, --j)
    //            ^list separator      ^comma operator
        std::cout << "i = " << i << " j = " << j << '\n';
 
    // * in a return statement
    // return log("an error!"), -1;
 
    // * in an initializer expression
    // MyClass(const Arg& arg)
    // : member{ throws_if_bad(arg), arg }
 
    // etc.
 
    // comma operators can be chained; the result of the last
    // (rightmost) expression is the result of the whole chain:
    int n = 1;
    int m = (++n, std::cout << "n = " << n << '\n', ++n, 2 * n);
    // m is now 6
    std::cout << "m = " << (++m, m) << '\n';
 
}

i = 0 j = 10
i = 1 j = 9
i = 2 j = 8
i = 3 j = 7
i = 4 j = 6
i = 5 j = 5
n = 2
m = 7

Оператор условия

Выражения оператора условия имеют вид

Первый операнд оператора условия оценивается и контекстуально преобразуется к типу bool. После завершения оценки значения и всех побочных эффектов первого операнда, если результат был true, вычисляется второй операнд. Если результат был false, вычисляется третий операнд.

Тип и категория значения условного выражения E1 ? E2 : E3 определяются по следующим правилам:

std::string str = 2 + 2 == 4 ? "OK" : throw std::logic_error("2 + 2 != 4");

2 + 2 == 4 ? throw 123 : throw 456;

struct A {};
 
struct B : A {};
 
using T = const B;
 
A a = true ? A() : T(); // Y = A(), TY = A, X = T(), TX = const B, Target = const A

int* intPtr;
 
using Mixed = decltype(true ? nullptr : intPtr);
 
static_assert(std::is_same_v<Mixed, int*>); // nullptr becoming int*

struct A
{
    int* m_ptr;
} a;
 
int* A::* memPtr = &A::m_ptr; // memPtr is a pointer to member m_ptr of A
 
// memPtr makes nullptr as type of pointer to member m_ptr of A
static_assert(std::is_same_v<decltype(false ? memPtr : nullptr), int*A::*>);
 
// a.*memPtr is now just pointer to int and nullptr also becomes pointer to int
static_assert(std::is_same_v<decltype(false ? a.*memPtr : nullptr), int*>);

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

LR operator?:(bool, L, R);

P operator?:(bool, P, P);

где LR — результат обычных арифметических преобразований, выполненных над L и R. Оператор «?:» перегрузить нельзя; эти сигнатуры функций существуют только для целей разрешения перегрузки.

Тип возвращаемого значения условного оператора также доступен как бинарный тип-свойство std::common_type.

#include <iostream>
#include <string>
 
struct Node
{
    Node* next;
    int data;
 
    // deep-copying copy constructor
    Node(const Node& other)
        : next(other.next ? new Node(*other.next) : NULL)
        , data(other.data)
    {}
 
    Node(int d) : next(NULL), data(d) {}
 
    ~Node() { delete next; }
};
 
int main()
{   
    // simple rvalue example
    int n = 1 > 2 ? 10 : 11;  // 1 > 2 is false, so n = 11
 
    // simple lvalue example
    int m = 10; 
    (n == m ? n : m) = 7; // n == m is false, so m = 7
 
    //output the result
    std::cout << "n = " << n << "\nm = " << m;
}

n = 11
m = 7

Стандартная библиотека

Многие классы стандартной библиотеки перегружают operator() для использования в качестве объектов-функций.

Оператор запятой не перегружается ни одним классом стандартной библиотеки. Библиотека boost использует operator, в boost.assign, boost.spirit и других библиотеках. Библиотека доступа к базам данных SOCI также перегружает operator,.

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены ретроактивно к ранее опубликованным стандартам C++.

1. Например, функции могут вызываться в инициализаторе переменной на уровне пространства имён, в этом контексте нет «вызывающей функции».

См. также

Порядок выполнения операторов Перегрузка операторов