Other operators

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <cstdio>
struct S
{
    int f1(double d)
    {
        return printf("%f \n", d); // вызов функции с переменным числом аргументов
    }
    int f2()
    {
        return f1(7); // вызов функции-члена, эквивалентно this->f1()
                      // целочисленный аргумент преобразован в double
    }
};
void f()
{
    puts("function called"); // вызов функции
}
int main()
{
    f();    // вызов функции
    S s;
    s.f2(); // вызов функции-члена
}

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()
{
    // запятая часто используется для выполнения более одного выражения
    // там, где грамматика языка позволяет только одно выражение:
    // * в третьем компоненте цикла for
    for (int i = 0, j = 10; i <= j; ++i, --j)
    //            ^разделитель списка      ^оператор запятая
        std::cout << "i = " << i << " j = " << j << '\n';
    // * в операторе return
    // return log("an error!"), -1;
    // * в выражении инициализации
    // MyClass(const Arg& arg)
    // : member{ throws_if_bad(arg), arg }
    // и т.д.
    // операторы запятая могут быть объединены в цепочку; результат последнего
    // (самого правого) выражения является результатом всей цепочки:
    int n = 1;
    int m = (++n, std::cout << "n = " << n << '\n', ++n, 2 * n);
    // m теперь равно 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

Условный оператор

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

E1 вычисляется и контекстно преобразуется в bool ; если результат равен true , результатом условного выражения является значение E2 ; в противном случае результатом условного выражения является значение E3 .

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

Этап 1

Если оба E2 и E3 имеют тип void , результатом является rvalue (до C++11) prvalue (начиная с C++11) типа void .

Если ровно один из E2 и E3 имеет тип void :

• Если операнд типа void является (возможно, заключенным в скобки) throw выражением , результат имеет тип и категорию значения другого операнда ^[1] . Если другой операнд является битовым полем , результат также является битовым полем.
• В противном случае программа является некорректной.

Если ни один из E2 и E3 не имеет тип void , переходите к следующему этапу.

2 + 2 == 4 ? throw 123 : throw 456; // результат имеет тип “void”
2 + 2 != 4 ? "OK" : throw "error";  // результат имеет тип “const char[3]”
                                    // даже если исключение всегда выбрасывается

Этап 2

Если E2 или E3 являются битовыми полями-lvalue (до C++11) битовыми полями-glvalue той же категории значения (начиная с C++11) и типов cv1 T и cv2 T соответственно, операнды считаются имеющими тип cv T для последующей обработки, где cv является объединением cv1 и cv2 .

Если E2 и E3 имеют разные типы и выполняется любое из следующих условий, переходите к этапу 3:

• По крайней мере один из E2 и E3 является (возможно, cv-квалифицированным) классным типом.
• Оба E2 и E3 являются lvalue одного и того же типа (до C++11) glvalue одной и той же категории значения и одного типа (начиная с C++11) за исключением cv-квалификации.

В противном случае переходите к этапу 4.

Этап 3

Предпринимаются попытки сформировать последовательность неявного преобразования ^[2] из операндного выражения X типа TX к целевому типу связанному с типом TY операндного выражения Y следующим образом:

• Если Y является lvalue, целевой тип — TY& , но неявная последовательность преобразований может быть сформирована только если ссылка будет связываться напрямую с lvalue (до C++11) glvalue (начиная с C++11) .

• Если Y является rvalue (до C++11) prvalue (начиная с C++11) или если ни одна из приведенных выше последовательностей преобразований не может быть сформирована, и хотя бы один из TX и TY является (возможно, cv-квалифицированным) классовым типом:
  • Если TX и TY являются одним и тем же классовым типом (игнорируя cv-квалификацию):
    • Если TY имеет как минимум такую же cv-квалификацию, как TX , целевой тип — TY .
    • В противном случае последовательность преобразований не формируется.
  • В противном случае, если TY является базовым классом для TX , целевой тип — TY с cv-квалификаторами TX .
  • В противном случае целевой тип — это тип Z , где Z — значение Y после применения стандартных преобразований lvalue-to-rvalue, array-to-pointer и function-to-pointer.
• В противном случае последовательность преобразований не формируется.

С помощью этого процесса определяется, может ли быть сформирована неявная последовательность преобразования из E2 в целевой тип, определённый для E3 , и наоборот.

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

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

Этап 4

В противном случае, результат является rvalue (до C++11) prvalue (начиная с C++11) .

• Если E2 и E3 имеют разные типы, и хотя бы один из них имеет (возможно, cv-квалифицированный) классовый тип, переходите к этапу 5.
• В противном случае переходите к этапу 6.

Этап 5

Разрешение перегрузки выполняется с использованием встроенных кандидатов для попытки преобразования операндов во встроенные типы:

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

Этап 6

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

• E2 и E3 имеют одинаковый тип. В этом случае результат имеет этот тип и инициализируется копирующей инициализацией с использованием выбранного операнда.
• Оба E2 и E3 имеют арифметический тип или тип перечисления. В этом случае применяются обычные арифметические преобразования для приведения их к общему типу, и результат имеет этот тип.
• По крайней мере один из E2 и E3 является указателем. В этом случае применяются преобразования lvalue-to-rvalue, указателей , указателей на функции (since C++17) и квалификационные преобразования для приведения их к составному типу указателя , и результат имеет этот тип.
• По крайней мере один из E2 и E3 является указателем на член. В этом случае применяются преобразования lvalue-to-rvalue, указателей на члены , указателей на функции (since C++17) и квалификационные преобразования для приведения их к составному типу указателя , и результат имеет этот тип.

int* intPtr;
using Mixed = decltype(true ? nullptr : intPtr);
static_assert(std::is_same_v<Mixed, int*>); // nullptr становится int*
struct A
{
    int* m_ptr;
} a;
int* A::* memPtr = &A::m_ptr; // memPtr - указатель на член m_ptr структуры A
// memPtr делает nullptr типом указателя на член m_ptr структуры A
static_assert(std::is_same_v<decltype(false ? memPtr : nullptr), int*A::*>);
// a.*memPtr теперь просто указатель на int и nullptr также становится указателем на int
static_assert(std::is_same_v<decltype(false ? a.*memPtr : nullptr), int*>);

1. ↑ Такой условный оператор часто использовался в C++11 constexpr программировании до C++14.
2. ↑ Доступ к членам , является ли функция преобразования удаленной (начиная с C++11) и является ли операнд битовым полем - игнорируются.

Перегрузки

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

где LR является результатом usual arithmetic conversions , применённых к L и R .

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

#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. ↑ Например, функции могут вызываться в инициализаторе переменной пространства имен, в этом контексте нет "вызывающей функции".

Смотрите также

Приоритет операторов
Перегрузка операторов