其他运算符

不适合任何其他主要类别的运算符的汇集。

运算符	运算符名	示例	描述
(...)	函数调用	f(...)	以令或更多参数调用 f()
,	逗号运算符	a, b	求值表达式 a ，舍弃其返回值并完成任何副效应，然后求值表达式 b ，返回此求值的类型和结果
(type)	转型	(type)a	转型 a 的类型为 type
? :	条件运算符	a ? b : c	若 a 逻辑上为真（不求值为零）则求值表达式 b ，否则求值表达式 c
sizeof	sizeof 运算符	sizeof a	a 的字节大小
_Alignof (C11 起)	_Alignof 运算符	_Alignof(type)	type 对齐

函数调用

函数调用表达式拥有形式


表达式 `(` 实参列表(可选) `)`

其中

表达式	-	任何指向函数指针类型表达式（在左值转换后）
实参列表	-	任何完整对象类型表达式（不能是逗号运算符）的逗号分隔列表。调用不接受参数的函数时可以省略。

函数调用表达式的行为，取决于正在调用的函数的原型是否在调用点处于作用域中。

调用有原型函数

1) 形参数量必须等于实参数量（除非使用省略号形参）。

2) 必须存在如同赋值的隐式转换，将对应实参的无限定类型转换为形参类型。

另外，对于每个在 [ 和 ] 间使用关键词 static 的数组类型形参，实参表达式所指代的数组元素数，必须不少于形参的大小表达式中指定的数量。

(C99 起)

3) 以未指定顺序无序地求值实参。

4) 进行赋值，复制每个实参到对应的函数形参，忽略形参类型及其可能为递归的元素或成员上的类型限定符，若存在（注意：函数能修改其形参，而这些修改不影响实参， C 函数调用只有以值调用）。

若有尾随省略号形参，则在剩余实参上进行默认参数提升，这使得它们可由 va_list 访问。

5) 执行函数，而其返回值成为函数调用表达式的值（若函数返回 void ，则函数调用表达式为 void 表达式）。

void f(char* p, int x) {}
int main(void)
{
    f("abc", 3.14); // 数组到指针和 float 到 int 转换
}

调用无原型函数

1) 以未指定顺序无序地求值实参。

2) 在每个实参表达式上进行默认参数提升。

3) 进行赋值，复制每个实参到对应的函数形参，忽略形参类型及其可能为递归的元素或成员上的类型限定符，若存在。

4) 执行函数，而其所返回的值成为函数调用表达式的值（若函数返回 void ，则函数调用表达式为 void 表达式）

void f(); // 无原型
int main(void)
{
    f(1, 1.0f); // UB ，除非定义 f 为接收一个 int 和一个 double
}
void f(int a, double c) {}

调用无原型函数的行为未定义，若

实参数量不匹配形参数量
提升后的实参类型与提升后形参类型不兼容，除了

认为相同整数类型的有符号和无符号版本兼容，若参数值能以两个类型表示。
认为指向 void 指针和指向（可有 cvr 限定的）字符类型指针兼容

(C23 前)

注解

指代要调用的函数的表达式和所有参数的求值相对于彼此无序（但在函数开始执行前有一个序列点）

(*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)(); // 亦 OK
}

必须用在作用域中的原型调用忽略不使用实参的函数，如 printf （这种函数的原型需要使用尾随省略号形参），以避免未定义行为。

当前准备函数形参的语义的标准遣词是有缺陷的，因为它指定在调用时形参从实参赋值，这错误地拒绝了 const 限定的形参或成员类型，并且不恰当地应用了在许多平台上对于函数形参无法实现的 volatile 语义。 C11 后的缺陷报告 DR 427 提议将该语义从赋值改为初始化，但被作为非缺陷关闭。

其表达式完全由一个标识符组成，而未声明该标识符的函数调用表达式，表现为通过将该标识符声明如下

extern int identifier(); // 返回 int 且无原型

故下列完整程序在 C89 中合法：

main() {
    int n = atoi("123"); // 隐式声明 atoi 为 int atoi()
}

(C99 前)

逗号运算符

逗号运算符表达式拥有形式


lhs `,` rhs

其中

lhs	-	任何表达式
rhs	-	任何异于另一逗号运算符的表达式（换言之，逗号运算符的结合性为从左到右）

首先，求值左运算数 lhs 并舍弃其结果值。

然后，发生序列点，从而 lhs 的所有副效应完成。

然后，求值右运算数 rhs ，而逗号运算符作为非左值返回其结果。

注意

lhs 的类型可为 void （即可为对返回 void 的函数的调用，或能为转型到 void 的表达式）。

逗号运算符在 C++ 中可为左值，但 C 中决不是。

逗号运算符可返回结构体（其他返回结构体的表达式仅有复合字面量、函数调用、赋值和条件运算符）。

下列语境中，逗号运算符不能出现于表达式的顶层，因为逗号有不同含义：

函数调用中的实参列表
初始化器表达式或初始化器列表
泛型选择

若必须在这种语境中使用逗号运算符，则必须加括号：

// 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 ：大小为 3 的 VLA 数组（因为 (2, 3) 不是常量表达式故为 VLA ）

常量表达式中不允许逗号，不管它是否出现于顶层

// static int n = (1,2); // 错误：常量表达式不能调用逗号运算符

转型运算符

见转型运算符

条件运算符

条件运算符表达式拥有形式


条件 `?` 表达式真 `:` 表达式假

其中

条件	-	标量类型表达式
表达式真	-	若条件比较不等于零则将求值的表达式
表达式假	-	若条件比较等于零则将求值的表达式

仅允许下列表达式为表达式真和表达式假

二个任何算术类型的表达式
二个相同结构体或联合体类型的表达式
二个 void 类型表达式
二个指针类型表达式，指向兼容的类型，忽略 cvr 限定符

二个 nullptr_t 类型表达式

(C23 起)

一个表达式是指针而另一个是空指针常量（例如 NULL ）或 nullptr_t 值 (C23 起)
一个表达式是指向对象指针而另一个是指向 void （可有限定）指针

1) 首先，求值条件。此求值后有序列点。

2) 若条件的结果比较不等于零，则执行表达式真，否则执行表达式假。

3) 进行从结果到共同类型的转换，转换定义如下：

1) 若表达式拥有算术类型，则共同类型为通常算术转换后的类型

2) 若表达式拥有结构体/联合体类型，则共同类型为结构体/联合体类型

3) 若表达式都是 void ，则整个条件运算符表达式就是 void 表达式

4) 若一个表达式为指针而另一个是空指针常量或 nullptr_t 值 (C23 起)，则类型为该指针的类型

5) 若两个表达式都是指针，则结果为指向组合两个被指向类型的 cvr 限定符的类型的指针（即若一个指针是 const int* 而另一个是 volatile int* ，则结果为 const volatile int* ），而假如类型不同，则被指向类型为两类型的合成类型。

6) 若一个表达式是指向 void 指针，则结果为指向带组合的 cvr 限定符的 void 的指针。

7) 若两者均拥有 nullptr_t 类型，则共同类型亦为 nullptr_t

(C23 起)

#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))           // 因不完整类型而错误

注解

条件运算符决不是左值表达式，尽管它可以返回结构体/联合体类型的对象。其他可以返回结构体的表达式仅有赋值、逗号、函数调用和复合字面量。

注意 C++ 中它可以为左值表达式。

此运算符和赋值的相对优先级上的细节见运算符优先级。

条件运算符拥有从右到左结合性，这允许链式写法

struct vehicle v = arg == 'B' ? bus      :
                   arg == 'A' ? airplane :
                   arg == 'T' ? train    :
                   arg == 'C' ? car      :
                   arg == 'H' ? horse    :
                                feet;

sizeof 运算符

见 sizeof 运算符

_Alignof 运算符

见 _Alignof 运算符

引用

C17 标准（ISO/IEC 9899:2018）：

6.5.2.2 Function calls （第 58-59 页）

6.5.3.4 The sizeof and _Alignof operators （第 64-65 页）

6.5.4 Cast operators （第 65-66 页）

6.5.15 Conditional operator （第 71-72 页）

6.5.17 Comma operator （第 75 页）

C11 标准（ISO/IEC 9899:2011）：

6.5.2.2 Function calls （第 81-82 页）

6.5.3.4 The sizeof and _Alignof operators （第 90-91 页）

6.5.4 Cast operators （第 91 页）

6.5.15 Conditional operator （第 100 页）

6.5.17 Comma operator （第 105 页）

C99 标准（ISO/IEC 9899:1999）：

6.5.2.2 Function calls （第 71-72 页）

6.5.3.4 The sizeof operator （第 80-81 页）

6.5.4 Cast operators （第 81 页）

6.5.15 Conditional operator （第 90-91 页）

6.5.17 Comma operator （第 94 页）

C89/C90 标准（ISO/IEC 9899:1990）：

3.3.2.2 Function calls

3.3.3.4 The sizeof operator

3.3.4 Cast operators

3.3.15 Conditional operator

3.3.17 Comma operator

参阅

运算符优先级

常用运算符
赋值	自增自减	算术	逻辑	比较	成员访问	其他
a = b a += b a -= b a *= b a /= b a %= b a &= b a \|= b a ^= b a <<= b a >>= b	++a --a a++ a--	+a -a a + b a - b a * b a / b a % b ~a a & b a \| b a ^ b a << b a >> b	!a a && b a \|\| b	a == b a != b a < b a > b a <= b a >= b	a[b] *a &a a->b a.b	a(...) a, b (type) a ? : sizeof _Alignof (C11 起)

语言
头文件
类型支持
程序工具
变参数函数支持
动态内存管理
错误处理
字符串库
算法
数值
日期和时间工具
输入/输出支持
本地化支持
并发支持 (C11)
技术规范
符号索引

基本概念
关键词
预处理器
语句
表达式
初始化
声明
函数
杂项
C 的历史
技术规范

通用
值类别
求值顺序与顺序点
常量表达式
隐式转换
泛型选择 (C11)
常量及字面量
整数常量
浮点常量
字符常量
true/false (C23)
nullptr (C23)
字符串字面量
复合字面量 (C99)
运算符
运算符优先级
成员访问与间接
逻辑运算符
比较运算符
算术运算符
赋值运算符
自增减
函数调用、逗号、条件运算符
sizeof
_Alignof (C11)
转型运算符