其他运算符

不属于其他主要类别的一组运算符。

运算符	运算符名称	示例	描述
(...)	函数调用	f(...)	调用函数 f()，带零个或多个参数
,	逗号运算符	a, b	计算表达式 a，忽略其返回值并完成所有副作用，然后计算表达式 b，返回此计算的类型和结果
(类型)	类型转换	(类型)a	将 a 的类型强制转换为类型
? :	条件运算符	a ? b : c	如果 a 在逻辑上为真（不计算为零），则计算表达式 b，否则计算表达式 c
sizeof	sizeof 运算符	sizeof a	a 的字节大小
_Alignof (自 C11)	_Alignof 运算符	_Alignof(类型)	类型需要的对齐方式
typeof	typeof 运算符	typeof(a)	a 的类型

内容

1 函数调用
2 逗号运算符
3 说明
4 强制转换运算符
5 条件运算符
- 5.1 说明
6 sizeof 运算符
7 _Alignof 运算符
8 typeof 运算符
9 参考资料
10 另请参阅

[编辑] 函数调用

函数调用表达式具有以下形式


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

其中

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

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

[编辑] 调用带原型声明的函数

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); // array to pointer and float to int conversions
}

调用不带原型声明的函数

1) 参数按未指定顺序且无排序求值。

2) 对每个参数表达式执行默认参数提升。

3) 执行赋值以将每个参数的值复制到相应的函数参数，忽略参数类型及其可能递归的元素或成员（如果有）上的任何类型限定符。

4) 执行函数，其返回值成为函数调用表达式的值（如果函数返回 void，则函数调用表达式是 void 表达式）

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) {}

如果以下情况发生，则不带原型声明的函数调用的行为未定义

参数数量与参数数量不匹配。
参数的提升类型与参数的提升类型不兼容，除非

相同整数类型的带符号和无符号版本在参数值可由两种类型表示时被认为是兼容的。
指向 void 的指针和指向（可能限定了 cvr 的）字符类型的指针被认为是兼容的

(直到 C23)

[编辑] 说明

指定要调用的函数的表达式和所有参数的求值是无序的（但函数体开始执行之前有一个顺序点）

(*pf[f1()]) (f2(), f3() + f4()); // f1, f2, f3, f4 may be called in any order

虽然函数调用仅为指向函数的指针定义，但由于函数到指针的隐式转换，它适用于函数指示符。

int f(void) { return 1; }
int (*pf)(void) = f;
 
int main(void)
{
    f();    // convert f to pointer, then call
    (&f)(); // create a pointer to function, then call
 
    pf();    // call the function
    (*pf)(); // obtain the function designator, convert to pointer, then calls
 
    (****f)(); // convert to pointer, obtain the function, repeat 4x, then call
    (****pf)(); // also OK
}

忽略未使用参数的函数，例如 printf，必须在作用域内带原型声明调用（此类函数的原型必然使用尾部省略号参数）以避免调用未定义的行为。

准备函数参数的语义的当前标准措辞有缺陷，因为它指定参数是在调用时从参数分配的，这错误地拒绝了限定为 const 的参数或成员类型，并且不适当地应用了 volatile 的语义，而 volatile 在许多平台上对于函数参数来说是无法实现的。C11 后的缺陷报告 DR427 提议将此类语义从赋值更改为初始化，但被关闭为非缺陷。

函数调用表达式，其中表达式全部由一个标识符组成，而该标识符未声明，则该标识符的行为就像这样声明一样

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

因此，以下完整的程序是有效的 C89

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

(直到 C99)

[编辑] 逗号运算符

逗号运算符表达式具有以下形式


lhs `,` rhs

其中

lhs	-	任何表达式
rhs	-	除另一个逗号运算符之外的任何表达式（换句话说，逗号运算符的结合性是从左到右的）

首先，计算左操作数 lhs，并丢弃其结果值。

然后，发生顺序点，以便 lhs 的所有副作用都已完成。

然后，计算右操作数 rhs，并将其结果作为非左值由逗号运算符返回。

[编辑] 说明

lhs 的类型可以是 void（也就是说，它可以是调用返回 void 的函数，或者它可以是强制转换为 void 的表达式）

逗号运算符在 C++ 中可以是左值，但在 C 中永远不会

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

在以下上下文中，逗号运算符不能出现在表达式的顶层，因为逗号具有不同的含义

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

如果必须在这样的上下文中使用逗号运算符，则必须将其括起来

// int n = 2,3; // error, comma assumed to begin the next declarator
// int a[2] = {1,2,3}; // error: more initializers than elements
int n = (2,3), a[2] = {(1,2),3}; // OK
 
f(a, (t=3, t+2), c); // OK, first, stores 3 in t, then calls f with three arguments

顶层逗号运算符也不允许在数组边界中使用

// int a[2,3]; // error
int a[(2,3)]; // OK, VLA array of size 3 (VLA because (2,3) is not a constant expression)

逗号运算符不允许在常量表达式中使用，无论它是在顶层还是不在顶层

// static int n = (1,2); // Error: constant expression cannot call the comma operator

[编辑] 强制转换运算符

参见强制转换运算符

[编辑] 条件运算符

条件运算符表达式具有以下形式


条件 `?` 表达式-true `:` 表达式-false

其中

条件	-	标量类型的表达式
表达式-true	-	如果条件与零不相等，则将评估的表达式
表达式-false	-	如果条件与零相等，则将评估的表达式

以下表达式才允许作为表达式-true 和表达式-false

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

两个 nullptr_t 类型的表达式

(从 C23 开始)

一个表达式是指针，另一个是空指针常量（如 NULL）或 nullptr_t 值(从 C23 开始)
一个表达式是指向对象的指针，另一个是指向 void 的指针（可能已限定）

1) 首先，评估条件。在该评估之后有一个顺序点。

2) 如果条件的结果与零不相等，则执行表达式-true，否则执行表达式-false

3) 从评估结果执行到公共类型的转换，定义如下

1) 如果表达式具有算术类型，则公共类型是在通常的算术转换之后的类型

2) 如果表达式具有结构体/联合类型，则公共类型是该结构体/联合类型

3) 如果表达式都是 void，则整个条件运算符表达式是一个 void 表达式

4) 如果一个是指针，另一个是空指针常量或 nullptr_t 值(从 C23 开始)，则类型是该指针的类型

5) 如果两者都是指针，则结果是指向结合两个指向类型的 cvr 限定符的类型的指针（即，如果一个是 const int*，另一个是 volatile int*，则结果是 const volatile int*），如果类型不同，则指向的类型是组合类型。

6) 如果一个是指向 void 的指针，则结果是指向 void 的指针，并具有组合的 cvr 限定符

7) 如果两者都具有 nullptr_t 类型，则公共类型也是 nullptr_t

(从 C23 开始)

#define ICE(x) (sizeof(*(1 ? ((void*)((x) * 0l)) : (int*)1)))
 
// if x is an Integer Constant Expression then macro expands to
 
sizeof(*(1 ? NULL : (int *) 1))  // (void *)((x)*0l)) -> NULL
 
// according to point (4) this further converts into
 
sizeof(int)
 
// if x is not an Integer Constant Expression then macro expands to
// according to point (6)
 
(sizeof(*(void *)(x))           // Error due incomplete type

[编辑] 备注

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

请注意，在 C++ 中，它可能是左值表达式。

有关此运算符和赋值的相对优先级的详细信息，请参见运算符优先级。

条件运算符具有从右到左的结合性，这允许链接

运行此代码

#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);
}

[编辑] 参考资料

C23 标准 (ISO/IEC 9899:2024)

6.5.2.2 函数调用 (p: TBD)

6.5.3.4 sizeof 和 _Alignof 运算符 (p: TBD)

6.5.4 强制转换运算符 (p: TBD)

6.5.15 条件运算符 (p: TBD)

6.5.17 逗号运算符 (p: TBD)

6.7.3.5 typeof 说明符 (p: 115-118)

C17 标准 (ISO/IEC 9899:2018)

6.5.2.2 函数调用 (p: 58-59)

6.5.3.4 sizeof 和 _Alignof 运算符 (p: 64-65)

6.5.4 强制转换运算符 (p: 65-66)

6.5.15 条件运算符 (p: 71-72)

6.5.17 逗号运算符 (p: 75)

C11 标准 (ISO/IEC 9899:2011)

6.5.2.2 函数调用 (p: 81-82)

6.5.3.4 sizeof 和 _Alignof 运算符 (p: 90-91)

6.5.4 强制转换运算符 (p: 91)

6.5.15 条件运算符 (p: 100)

6.5.17 逗号运算符 (p: 105)

C99 标准 (ISO/IEC 9899:1999)

6.5.2.2 函数调用 (p: 71-72)

6.5.3.4 sizeof 运算符 (p: 80-81)

6.5.4 强制转换运算符 (p: 81)

6.5.15 条件运算符 (p: 90-91)

6.5.17 逗号运算符 (p: 94)

C89/C90 标准 (ISO/IEC 9899:1990)

3.3.2.2 函数调用

3.3.3.4 sizeof 运算符

3.3.4 强制转换运算符

3.3.15 条件运算符

3.3.17 逗号运算符

[编辑] 另见

运算符优先级

常用运算符
赋值	递增递减	算术	逻辑	比较	成员访问	其他
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 a ? b : c sizeof _Alignof (自 C11)

C++ 文档用于其他运算符

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

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

cppreference.com

命名空间

变体

视图

操作

其他运算符

内容

[编辑] 函数调用

[编辑] 调用带原型声明的函数

调用不带原型声明的函数

[编辑] 说明

[编辑] 逗号运算符

[编辑] 说明

[编辑] 强制转换运算符

[编辑] 条件运算符

[编辑] 备注

[编辑] `sizeof` 运算符

[编辑] `_Alignof` 运算符

[编辑] `typeof` 运算符

[编辑] 参考资料

[编辑] 另见

导航

工具箱

cppreference.com

命名空间

变体

视图

操作

其他运算符

内容

[编辑] 函数调用

[编辑] 调用带原型声明的函数

调用不带原型声明的函数

[编辑] 说明

[编辑] 逗号运算符

[编辑] 说明

[编辑] 强制转换运算符

[编辑] 条件运算符

[编辑] 备注

[编辑] sizeof 运算符

[编辑] _Alignof 运算符

[编辑] typeof 运算符

[编辑] 参考资料

[编辑] 另见

导航

工具箱

[编辑] `sizeof` 运算符

[编辑] `_Alignof` 运算符

[编辑] `typeof` 运算符