命名空间
变体
操作

其他运算符

来自 cppreference.cn
< c‎ | language
 
C
 
C 语言
 
表达式
 

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

本节尚不完整
原因：考虑为此表和其他涵盖多个主题的表提供更通用的目录
运算符 运算符名称 示例 描述
(...) 函数调用 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 所需的对齐方式
typeof typeof 运算符 typeof(a) a 的类型

目录

[编辑] 函数调用

函数调用表达式的形式为

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

其中

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

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

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

1) 参数的数量必须等于实参的数量（除非使用了省略号参数）。
2) 每个参数的类型必须是一种类型，使得存在隐式转换（如同赋值），可以将相应实参的非限定类型转换为参数的类型。
此外，对于每个使用关键字 static 在 [ 和 ] 之间的数组类型参数，实参表达式必须指定一个指向数组元素的指针，该数组至少具有参数的大小表达式中指定的元素数量。
 (自 C99 起)
3) 实参的求值顺序是未指定的且没有顺序。
4) 执行赋值以将每个实参的值复制到相应的函数参数，忽略参数类型及其可能的递归元素或成员上的任何类型限定符（注意：函数可以修改其参数，但这些更改不会影响实参；C 函数调用仅是按值调用）。
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 的语义，这在许多平台上对于函数参数是无法实现的。C11 后的缺陷报告 DR427 提出了将此类语义从赋值更改为初始化的建议，但被关闭为非缺陷。

如果函数调用表达式中的 表达式 完全由标识符组成，并且该标识符未声明，则其行为就好像该标识符声明为

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

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

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

[编辑] 逗号运算符

逗号运算符表达式的形式为

左操作数 , 右操作数

其中

左操作数 - 任何表达式
右操作数 - 任何表达式，但不能是另一个逗号运算符（换句话说，逗号运算符的结合性是从左到右）

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

然后，发生序列点，以便完成 左操作数 的所有副作用。

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

[编辑] 注释

左操作数 的类型可以是 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

[编辑] 类型转换运算符

请参见类型转换运算符

[编辑] 条件运算符

条件运算符表达式的形式为

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

其中

条件 - 标量类型的表达式
真表达式 - 如果条件比较不等于零，则将计算的表达式
假表达式 - 如果条件比较等于零，则将计算的表达式

只有以下表达式允许作为 真表达式 和 假表达式

  • 两个任何算术类型的表达式
  • 两个相同结构体或联合体类型的表达式
  • 两个 void 类型的表达式
  • 两个指针类型的表达式，指向兼容的类型，忽略 cvr 限定符
(自 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)))
 
// 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);
}

[编辑] sizeof 运算符

请参见sizeof 运算符

[编辑] _Alignof 运算符

请参见_Alignof 运算符

[编辑] typeof 运算符

请参见typeof 运算符

[编辑] 参考文献

  • C23 标准 (ISO/IEC 9899:2024)
  • 6.5.2.2 函数调用 (页码: 待定)
  • 6.5.3.4 sizeof 和 _Alignof 运算符 (页码: 待定)
  • 6.5.4 类型转换运算符 (页码: 待定)
  • 6.5.15 条件运算符 (页码: 待定)
  • 6.5.17 逗号运算符 (页码: 待定)
  • 6.7.3.5 Typeof 说明符 (页码: 115-118)
  • C17 标准 (ISO/IEC 9899:2018)
  • 6.5.2.2 函数调用 (页码: 58-59)
  • 6.5.3.4 sizeof 和 _Alignof 运算符 (页码: 64-65)
  • 6.5.4 类型转换运算符 (页码: 65-66)
  • 6.5.15 条件运算符 (页码: 71-72)
  • 6.5.17 逗号运算符 (页码: 75)
  • C11 标准 (ISO/IEC 9899:2011)
  • 6.5.2.2 函数调用 (页码: 81-82)
  • 6.5.3.4 sizeof 和 _Alignof 运算符 (页码: 90-91)
  • 6.5.4 类型转换运算符 (页码: 91)
  • 6.5.15 条件运算符 (页码: 100)
  • 6.5.17 逗号运算符 (页码: 105)
  • C99 标准 (ISO/IEC 9899:1999)
  • 6.5.2.2 函数调用 (页码: 71-72)
  • 6.5.3.4 sizeof 运算符 (页码: 80-81)
  • 6.5.4 类型转换运算符 (页码: 81)
  • 6.5.15 条件运算符 (页码: 90-91)
  • 6.5.17 逗号运算符 (页码: 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 起)
(直到 C23)

alignof
(自 C23 起)

C++ 文档 关于 其他运算符
Retrieved from "https://cppreference.cn/mwiki/index.php?title=c/language/operator_other&oldid=161471"