Other operators

Набор операторов, которые не подходят ни к одной из других основных категорий.

Вызов функции

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

где

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

Вызов функции с прототипом

void f(char* p, int x) {}
int main(void)
{
    f("abc", 3.14); // array to pointer and float to int conversions
}

void f(); // no prototype
int main(void)
{
    f(1, 1.0f); // UB unless f is defined to take an int and a double
}
void f(int a, double c) {}

Примечания

Вычисления expression , которое обозначает вызываемую функцию, и всех аргументов являются неупорядоченными относительно друг друга (но существует точка следования перед началом выполнения тела функции)

(*pf[f1()]) (f2(), f3() + f4()); // функции f1, f2, f3, f4 могут быть вызваны в произвольном порядке

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

int f(void) { return 1; }
int (*pf)(void) = f;
int main(void)
{
    f();    // преобразование f в указатель, затем вызов
    (&f)(); // создание указателя на функцию, затем вызов
    pf();    // вызов функции
    (*pf)(); // получение обозначения функции, преобразование в указатель, затем вызов
    (****f)(); // преобразование в указатель, получение функции, повтор 4 раза, затем вызов
    (****pf)(); // также корректно
}

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

Текущая стандартная формулировка семантики подготовки параметров функции является дефектной, поскольку она указывает, что параметры присваиваются из аргументов при вызове, что ошибочно отвергает const-квалифицированные типы параметров или членов и неуместно применяет семантику volatile, которая нереализуема для параметров функции на многих платформах. Пост-C11 отчёт о дефекте DR427 предложил изменение такой семантики с присваивания на инициализацию, но был закрыт как не-дефект.

extern int identifier(); // returns int and has no prototype

main()
{
    int n = atoi("123"); // implicitly declares atoi as int atoi()
}

Оператор запятая

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

где

Сначала вычисляется левый операнд, lhs , и его результирующее значение отбрасывается.

Затем происходит точка следования , так что все побочные эффекты lhs завершаются.

Затем вычисляется правый операнд, rhs , и его результат возвращается оператором запятой как не-lvalue .

Примечания

Тип lhs может быть void (то есть это может быть вызов функции, возвращающей void , или выражение с приведением типа к void )

Оператор запятая может быть lvalue в C++, но никогда в C

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

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

• список аргументов в вызове функции
• выражение инициализации или initializer list
• generic selection

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

// int n = 2,3; // ошибка: запятая предполагает начало следующего декларатора
// int a[2] = {1,2,3}; // ошибка: больше инициализаторов, чем элементов
int n = (2,3), a[2] = {(1,2),3}; // OK
f(a, (t=3, t+2), c); // OK: сначала сохраняет 3 в t, затем вызывает f с тремя аргументами

Оператор запятой верхнего уровня также запрещен в границах массива

// int a[2,3]; // ошибка
int a[(2,3)]; // OK, VLA массив размера 3 (VLA, потому что (2,3) не является константным выражением)

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

// static int n = (1,2); // Ошибка: константное выражение не может вызывать оператор запятой

Оператор приведения

См. cast operator

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

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

где

Только следующие выражения разрешены в качестве expression-true и expression-false

• два выражения любого арифметического типа
• два выражения одинакового struct или union типа
• два выражения типа void
• два выражения указательного типа, указывающие на типы, которые являются совместимыми , игнорируя cvr-квалификаторы

• одно выражение является указателем, а другое — константой нулевого указателя (такой как NULL ) или значением типа nullptr_t (начиная с C23)
• одно выражение является указателем на объект, а другое — указателем на void (возможно, с квалификаторами)

#define ICE(x) (sizeof(*(1 ? ((void*)((x) * 0l)) : (int*)1)))
// если x является целочисленным константным выражением, то макрос раскрывается в
sizeof(*(1 ? NULL : (int *) 1))  // (void *)((x)*0l)) -> NULL
// согласно пункту (4) это далее преобразуется в
sizeof(int)
// если x не является целочисленным константным выражением, то макрос раскрывается
// согласно пункту (6)
(sizeof(*(void *)(x))           // Ошибка из-за неполного типа

Примечания

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

Обратите внимание, что в C++ это может быть lvalue-выражение.

См. приоритет операторов для получения подробной информации об относительном приоритете этого оператора и присваивания.

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

#include <assert.h>
enum vehicle { bus, airplane, train, car, horse, feet };
enum vehicle choose(char arg)
{
    return arg == 'B' ? bus      :
           arg == 'A' ? airplane :
           arg == 'T' ? train    :
           arg == 'C' ? car      :
           arg == 'H' ? horse    :
                        feet     ;
}
int main(void)
{
    assert(choose('H') == horse && choose('F') == feet);
}

sizeof оператор

См. sizeof operator

_Alignof оператор

См. _Alignof operator

typeof операторы

См. typeof operators

Ссылки

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

• Приоритет операторов