4.3 运算符
| 算术运算符 | + - * / % ++ -- |
| 关系运算符 | > < == >= <= != |
| 逻辑运算符 | ! && || |
| 赋值运算符 | =及其扩展赋值运算符 += -= *= /= %= >>= <<= &= ^= |= |
| 条件运算符 | ? : |
| 位运算符 | << >> ~ | ^ & |
| 逗号运算符 | , |
| 指针运算符 | * & |
| 求字节数运算符 | sizeof |
| 强制类型转换运算符 | (类型) |
| 成员运算符 | . -> |
| 下标运算符 | [] |
| 其他 | 如函数调用运算符() |
4.3.1 算术运算符
假设变量 A 的值为 10，变量 B 的值为 20，则：
| 运算符 | 描述 | 实例 |
| + | 把两个操作数相加 | A + B 将得到 30 |
| - | 从第一个操作数中减去第二个操作数 | A - B 将得到 -10 |
| * | 把两个操作数相乘 | A * B 将得到 200 |
| / | 用第一个数除以第二个数 | B / A 将得到 2 两个实数相除的结果为双精度数；两个整数相除的结果是整数 |
| % | 取模运算符，结果为第一个数除以第二数后的余数 | B % A 将得到 0 %运算符要求两个操作数为整数 |
| ++ | 自增运算符，整数值增加 1 | A++ 将得到 11 |
| -- | 自减运算符，整数值减少 1 | A-- 将得到 9 |
#include <iostream>
int main()
{
using namespace std;
int a, b;
cout.setf(ios_base::fixed, ios_base::floatfield);
cout << "输入一个整数：";//21
cin >> a;
cout << "输入第二个整数：";//10
cin >> b;
cout << "a = " << a << "; b = " << b << endl;
cout << "加法运算符： a + b = " << a + b << endl;
cout << "减法运算符： a - b = " << a - b << endl;
cout << "乘法运算符： a * b = " << a * b << endl;
cout << "除整运算符： a / b = " << a / b << endl;
cout << "取模运算符： c % d = " << a % b << endl;
cout << endl;
cout << endl;
cout << "当前a的值为：" << a << endl;
cout << "++运算符：直接执行 a++ = " << a++ << endl;
cout << "当前a的值为：" << a << endl;
cout << "--运算符：直接执行 a-- = " << a-- << endl;
cout << "当前a的值为：" << a << endl;
cout << "++运算符：直接执行 ++a = " << ++a << endl;
cout << "当前a的值为：" << a << endl;
cout << "--运算符：直接执行 --a = " << --a << endl;
cout << endl;
cout << endl;
cout << "当前a的值为：" << a << endl;
a++;
cout << "++运算符：间接执行(先执行，后输出) a++ = " << a << endl;
cout << "当前a的值为：" << a << endl;
a--;
cout << "--运算符：间接执行(先执行，后输出) a-- = " << a << endl;
cout << "当前a的值为：" << a << endl;
++a;
cout << "++运算符：间接执行(先执行，后输出) ++a = " << a << endl;
cout << "当前a的值为：" << a << endl;
--a;
cout << "--运算符：间接执行(先执行，后输出) --a = " << a << endl;
return 0;
}++i，--i 在使用i之前，先使i的值加/减1
i++，i-- 在使用i之后，使i的值加/减1
++i是先执行i=i+1，再使用i的值；而i++ 是先使用i的值，再执行i=i+1。
建议谨慎使用++和--运算符，只用最简单的形式，即i++， i--, 且把它们作为单独的表达式。
#include <iostream>
int main()
{
using namespace std;
int a = 10, b = 12;
cout << "a = 10 ; b = 12 ;" << endl;
cout <<"a++ + b++ = "<< a++ + b++ << endl;
a = 10, b = 12;
cout << "++a + ++b = " << ++a + ++b << endl;
a = 10, b = 12;
cout << "a-- + b-- = " << a-- + b-- << endl;
a = 10, b = 12;
cout << "--a + --b = " << --a + --b << endl;
cout << endl << endl;
a = 10, b = 12;
cout << "a = 10 ; b = 12 ;" << endl;
cout << "(a++) + (b++) = " << (a++) + (b++) << endl;
a = 10, b = 12;
cout << "(++a) + (++b) = " << (++a) + (++b) << endl;
a = 10, b = 12;
cout << "(a--) + (b--) = " << (a--) + (b--) << endl;
a = 10, b = 12;
cout << "(--a) + (--b) = " << (--a) + (--b) << endl;
return 0;
}4.3.2 关系运算符
在 C++ 中比较数值数据时可以使用关系运算符。字符也可以使用这些操作符进行比较，因为在 C++ 中字符被认为是数字值。每个关系运算符确定两个值之间是否存在特定的关系。
假设变量 A 的值为 10，变量 B 的值为 20，则：
| 运算符 | 描述 | 实例 |
| > | 检查左操作数的值是否大于右操作数的值，如果是则条件为真。 | (A > B) 不为真。 |
| < | 检查左操作数的值是否小于右操作数的值，如果是则条件为真。 | (A < B) 为真。 |
| == | 检查两个操作数的值是否相等，如果相等则条件为真。 | (A == B) 不为真。 |
| >= | 检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 | (A >= B) 不为真。 |
| <= | 检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 | (A <= B) 为真。 |
| != | 检查两个操作数的值是否相等，如果不相等则条件为真。 | (A != B) 为真。 |
#include <iostream>
using namespace std;
int main()
{
int a = 21;
int b = 10;
int c;
if (a == b)
{
cout << "Line 1 - a 等于 b" << endl;
}
else
{
cout << "Line 1 - a 不等于 b" << endl;
}
if (a < b)
{
cout << "Line 2 - a 小于 b" << endl;
}
else
{
cout << "Line 2 - a 不小于 b" << endl;
}
if (a > b)
{
cout << "Line 3 - a 大于 b" << endl;
}
else
{
cout << "Line 3 - a 不大于 b" << endl;
}
/* 改变 a 和 b 的值 */
a = 5;
b = 20;
if (a <= b)
{
cout << "Line 4 - a 小于或等于 b" << endl;
}
if (b >= a)
{
cout << "Line 5 - b 大于或等于 a" << endl;
}
return 0;
}4.3.3 逻辑运算符
假设变量 A 的值为 1，变量 B 的值为 0，则：
| 运算符 | 描述 | 实例 |
| && | 逻辑与运算符。如果两个操作数都 true，则条件为 true。 | (A && B) 为 false。 |
| || | 逻辑或运算符。如果两个操作数中有任意一个 true，则条件为 true。 | (A || B) 为 true。 |
| ！ | 逻辑非运算符。用来逆转操作数的逻辑状态，如果条件为 true 则逻辑非运算符将使其为false。 | !(A && B) 为 true。 |
#include <iostream>
using namespace std;
int main()
{
int a = 5;
int b = 20;
int c;
if (a && b)
{
cout << "Line 1 - 条件为真" << endl;
}
if (a || b)
{
cout << "Line 2 - 条件为真" << endl;
}
/* 改变 a 和 b 的值 */
a = 0;
b = 10;
if (a && b)
{
cout << "Line 3 - 条件为真" << endl;
}
else
{
cout << "Line 4 - 条件不为真" << endl;
}
if (!(a && b))
{
cout << "Line 5 - 条件为真" << endl;
}
return 0;
}4.3.4 赋值运算符
| 运算符 | 描述 | 实例 |
| = | 简单的赋值运算符，把右边操作数的值赋给左边操作数 | C = A + B 将把 A + B 的值赋给 C |
| += | 加且赋值运算符，把右边操作数加上左边操作数的结果赋值给左边操作数 | C += A 相当于 C = C + A |
| -= | 减且赋值运算符，把左边操作数减去右边操作数的结果赋值给左边操作数 | C -= A 相当于 C = C - A |
| *= | 乘且赋值运算符，把右边操作数乘以左边操作数的结果赋值给左边操作数 | C *= A 相当于 C = C * A |
| /= | 除且赋值运算符，把左边操作数除以右边操作数的结果赋值给左边操作数 | C /= A 相当于 C = C / A |
| %= | 求模且赋值运算符，求两个操作数的模赋值给左边操作数 | C %= A 相当于 C = C % A |
| >>= | 右移且赋值运算符 | C >>= 2 等同于 C = C >> 2 |
| <<= | 左移且赋值运算符 | C <<= 2 等同于 C = C << 2 |
| &= | 按位与且赋值运算符 | C &= 2 等同于 C = C & 2 |
| ^= | 按位异或且赋值运算符 | C ^= 2 等同于 C = C ^ 2 |
| |= | 按位或且赋值运算符 | C |= 2 等同于 C = C | 2 |
#include <iostream>
#include<bitset>
using namespace std;
int main()
{
int a = 21;
int c;
cout << "a = " << a << endl;
c = a;
cout << "= 运算符实例 c = a，c = " << c << endl;
c += a;
cout << "+= 运算符实例 c += a，c = " << c << endl;
c -= a;
cout << "-= 运算符实例 c -= a，c = " << c << endl;
c *= a;
cout << "*= 运算符实例 c *= a，c = " << c << endl;
c /= a;
cout << "/= 运算符实例 c /= a，c = " << c << endl;
c = 200;
cout << "a = " << a << "，c = " << c << endl;
c %= a;
cout << "%= 运算符实例 c %= a，c = " << c << "，c的二进制为：" << bitset<sizeof(int) * 8>(c) << endl;
c <<= 2;
cout << "<<= 运算符实例 c <<= 2，c = " << c << "，c的二进制为："<< bitset<sizeof(int)*8>(c)<<endl;
c >>= 2;
cout << ">>= 运算符实例 c >>= 2，c = " << c << "，c的二进制为：" << bitset<sizeof(int) * 8>(c) << endl;
c &= 2;
cout << "&= 运算符实例 c &= 2，c = " << c << "， c的二进制为：" << bitset<sizeof(int) * 8>(c) << endl;
c ^= 2;
cout << "^= 运算符实例 c ^= 2，c = " << c << " ，c的二进制为：" << bitset<sizeof(int) * 8>(c) << endl;
c |= 2;
cout << "|= 运算符实例 c |= 2，c = " << c << " ，c的二进制为：" << bitset<sizeof(int) * 8>(c) << endl;
return 0;
}4.3.5 条件运算符
Exp1 ? Exp2 : Exp3 ;
其中，Exp1、Exp2 和 Exp3 是表达式。请注意冒号的使用和位置。? : 表达式的值取决于 Exp1 的计算结果。如果 Exp1 为真，则计算 Exp2 的值，且 Exp2 的计算结果则为整个 ? : 表达式的值。如果 Exp1 为假，则计算 Exp3 的值，且 Exp3 的计算结果则为整个 ? : 表达式的值。
? : 被称为三元运算符，因为它需要三个操作数，可以用来代替如下所示的 if-else 语句：
if (condition)
{
var = X;
}
else
{
var = Y;
}例：
if (y < 10)
{
var = 30;
}
else
{
var = 40;
}上面的代码可以写成以下语句：
c = (y < 10) ? 30 : 40;
4.3.6 位运算符
位运算符作用于位，并逐位执行操作。&、 | 和 ^ 的真值表如下所示：
| p | q | p & q | p | q | p ^ q |
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
假设如果 A = 60，且 B = 13，现在以二进制格式表示，它们如下所示：
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 1100 0011
下表显示了 C++ 支持的位运算符。假设变量 A 的值为 60，变量 B 的值为 13，则：
| 运算符 | 描述 | 实例 |
| & | 按位与操作，按二进制位进行"与"运算。运算规则： 0&0=0; 0&1=0; 1&0=0; 1&1=1; | (A & B) 将得到 12，即为 0000 1100 |
| | | 按位或运算符，按二进制位进行"或"运算。运算规则： 0|0=0; 0|1=1; 1|0=1; 1|1=1; | (A | B) 将得到 61，即为 0011 1101 |
| ^ | 异或运算符，按二进制位进行"异或"运算。运算规则： 0^0=0; 0^1=1; 1^0=1; 1^1=0; | (A ^ B) 将得到 49，即为 0011 0001 |
| ~ | 取反运算符，按二进制位进行"取反"运算。运算规则： ~1=-2; ~0=-1; | (~A ) 将得到 -61，即为 1100 0011，一个有符号二进制数的补码形式。 |
| << | 二进制左移运算符。将一个运算对象的各二进制位全部左移若干位（左边的二进制位丢弃，右边补0）。 | A << 2 将得到 240，即为 1111 0000 |
| >> | 二进制右移运算符。将一个数的各二进制位全部右移若干位，正数左补0，负数左补1，右边丢弃。 | A >> 2 将得到 15，即为 0000 1111 |
#include <iostream>
using namespace std;
int main()
{
unsigned int a = 60; // 60 = 0011 1100
unsigned int b = 13; // 13 = 0000 1101
int c = 0;
c = a & b; // 12 = 0000 1100
cout << " c = " << c << endl;
c = a | b; // 61 = 0011 1101
cout << " c = " << c << endl;
c = a ^ b; // 49 = 0011 0001
cout << " c = " << c << endl;
c = ~a; // -61 = 1100 0011
cout << " c = " << c << endl;
c = a << 2; // 240 = 1111 0000
cout << " c = " << c << endl;
c = a >> 2; // 15 = 0000 1111
cout << " c = " << c << endl;
return 0;
}4.3.7 逗号运算符
使用逗号运算符是为了把几个表达式放在一起。
整个逗号表达式的值为系列中最后一个表达式的值。
从本质上讲，逗号的作用是将一系列运算按顺序执行。
表达式1, 表达式2
求解过程是：先求解表达式 1，再求解表达式 2。整个逗号表达式的值是表达式 2 的值。
最右边的那个表达式的值将作为整个逗号表达式的值，其他表达式的值会被丢弃。
例如：
a = (count = 19, c = 10, count + 1);
在这里，首先把 count 赋值为 19，把 c 赋值为 10，然后把 count 加 1，最后，把最右边表达式 count+1 的计算结果 20 赋给 a。上面表达式中的括号是必需的，因为逗号运算符的优先级低于赋值操作符。
尝试运行下面的实例，理解逗号运算符的用法。
#include <iostream>
using namespace std;
int main()
{
int i, j;
j = 10;
i = (j++, j + 100, 999 + j);
cout << i;
return 0;
}上面的程序中，j 最初的值为 10，然后自增到 11，这时 j 的值就为 11，然后再计算第二个表达式 j+100，最后 j（j 为 11） 再加上 999，最后 i 为 最后一个表达式的值 999+j，及 999+ 11=1010。
4.3.8 指针运算符
C++ 提供了两种指针运算符，一种是取地址运算符 &，一种是间接寻址运算符 *。
指针是一个包含了另一个变量地址的变量，您可以把一个包含了另一个变量地址的变量说成是"指向"另一个变量。变量可以是任意的数据类型，包括对象、结构或者指针。
取地址运算符 &
& 是一元运算符，返回操作数的内存地址。例如，如果 var 是一个整型变量，则 &var 是它的地址。该运算符与其他一元运算符具有相同的优先级，在运算时它是从右向左顺序进行的。
您可以把 & 运算符读作"取地址运算符"，这意味着，&var 读作"var 的地址"。
间接寻址运算符 *
第二个运算符是间接寻址运算符 *，它是 & 运算符的补充。* 是一元运算符，返回操作数所指定地址的变量的值。
请看下面的实例，理解这两种运算符的用法。
#include <iostream>
using namespace std;
int main()
{
int var;
int* ptr;
int val;
var = 3000;
ptr = &var;// 获取 var 的地址
val = *ptr;// 获取 ptr 的值
cout << "Value of var :" << var << endl;
cout << "Value of ptr :" << ptr << endl;
cout << "Value of val :" << val << endl;
return 0;
}4.3.9 求字节数运算符
sizeof 是一个关键字，它是一个编译时运算符，用于判断变量或数据类型的字节大小。
sizeof 运算符可用于获取类、结构、共用体和其他用户自定义数据类型的大小。
使用 sizeof 的语法如下：
sizeof(data type)
其中，data type是要计算大小的数据类型，包括类、结构、共用体和其他用户自定义数据类型。
#include <iostream>
using namespace std;
int main()
{
cout << "Size of char : " << sizeof(char) << endl;
cout << "Size of int : " << sizeof(int) << endl;
cout << "Size of short int : " << sizeof(short int) << endl;
cout << "Size of long int : " << sizeof(long int) << endl;
cout << "Size of float : " << sizeof(float) << endl;
cout << "Size of double : " << sizeof(double) << endl;
cout << "Size of wchar_t : " << sizeof(wchar_t) << endl;
return 0;
}请尝试下面的实例，理解 C++ 中 sizeof 的用法。复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。
4.3.10 强制类型转换运算符
强制转换运算符是一种特殊的运算符，它把一种数据类型转换为另一种数据类型。强制转换运算符是一元运算符，它的优先级与其他一元运算符相同。
大多数的 C++ 编译器都支持大部分通用的强制转换运算符：
(type)expression
其中，type 是转换后的数据类型。下面列出了 C++ 支持的其他几种强制转换运算符：
（1）const_cast<type> (expr): const_cast 运算符用于修改类型的 const / volatile 属性。除了 const 或 volatile 属性之外，目标类型必须与源类型相同。这种类型的转换主要是用来操作所传对象的 const 属性，可以加上 const 属性，也可以去掉 const 属性。
（2）dynamic_cast<type> (expr): dynamic_cast 在运行时执行转换，验证转换的有效性。如果转换未执行，则转换失败，表达式 expr 被判定为 null。dynamic_cast 执行动态转换时，type 必须是类的指针、类的引用或者 void*，如果 type 是类指针类型，那么 expr 也必须是一个指针，如果 type 是一个引用，那么 expr 也必须是一个引用。
（3）reinterpret_cast<type> (expr): reinterpret_cast 运算符把某种指针改为其他类型的指针。它可以把一个指针转换为一个整数，也可以把一个整数转换为一个指针。
（4）static_cast<type> (expr): static_cast 运算符执行非动态转换，没有运行时类检查来保证转换的安全性。例如，它可以用来把一个基类指针转换为派生类指针。
上述所有的强制转换运算符在使用类和对象时会用到。现在，请看下面的实例，理解 C++ 中如何使用一个简单的强制转换运算符。复制并黏贴下面的 C++ 程序到 test.cpp 文件中，编译并运行程序。
#include <iostream>
using namespace std;
int main()
{
double a = 21.09399;
float b = 10.20;
int c;
c = (int)a;
cout << "(int)a = " << c << endl;
c = (int)b;
cout << "(int)b = " << c << endl;
return 0;
}4.3.11 成员运算符
.（点）运算符和 ->（箭头）运算符用于引用类、结构和共用体的成员。
点运算符应用于实际的对象。箭头运算符与一个指向对象的指针一起使用。例如，假设有下面的结构：
struct Employee {
char first_name[16];
int age;
} emp;
（.）点运算符
下面的代码把值 "zara" 赋给对象 emp 的 first_name 成员：
strcpy(emp.first_name, "zara");
（->）箭头运算符
如果 p_emp 是一个指针，指向类型为 Employee 的对象，则要把值 "zara" 赋给对象 emp 的 first_name 成员，需要编写如下代码：
strcpy(p_emp->first_name, "zara");
-> 称为箭头运算符，它是由一个减号加上一个大于号组成。
简而言之，访问结构的成员时使用点运算符，而通过指针访问结构的成员时，则使用箭头运算符。
4.3.12 下标运算符
语法：postfix-expression [ expression ]
备注：postfix 表达式 (，它也可以是一个主表达式，) 后跟下标运算符 [ ] 指定数组索引。
通常，postfix-expression 表示的值是指针值（如数组标识符）expression 是整数值 (包括枚举类型) 。但是，从语法上来说，只需要一个表达式是指针类型，另一个表达式是整型。 因此，整数值可以位于postfix-expression位置，指针值可以位于表达式或下标位置的方括号中。考虑以下代码片断：
int nArray[5] = { 0, 1, 2, 3, 4 };
cout << nArray[2] << endl; // prints "2"
cout << 2[nArray] << endl; // prints "2"
在前面的示例中，表达式 nArray[2] 与 2[nArray] 相同。 原因是下标表达式的结果 e1[e2] 由以下项给出：
*((e2) + (e1))
表达式生成的地址不是来自地址 e1 的 e2 字节。相反，将缩放地址以生成数组e2中的下一个对象。例如：
double aDbl[2];
和的地址aDb[0]是aDb[1]8字节分开的 - 类型对象的大小double。根据对象类型进行这种缩放由 C++ 语言自动完成，在加法运算符中定义，其中讨论了指针类型的操作数的加法和减法。
下标表达式还可以有多个下标，如下所示：
expression1 [ expression2 ] [ expression3 ] ...
下标表达式从左至右关联。 首先计算最左侧的下标表达式 expression1 [expression2] 。 通过添加 expression1 和 expression2 得到的地址构成一个指针表达式；然后 expression3 将添加到此指针表达式，从而构成一个新的指针表达式，依此类推，直到添加最后一个下标表达式。间接运算符 () 最后一个下标表达式后应用，除非最终指针值 * 处理数组类型。
具有多个下标的表达式引用多维数组的元素。 多维数组是其元素为数组的数组。 例如，三维数组的第一个元素是一个具有两个维度的数组。 以下示例声明并初始化字符的简单二维数组：
// expre_Subscript_Operator.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;
#define MAX_ROWS 2
#define MAX_COLS 2
int main() {
char c[ MAX_ROWS ][ MAX_COLS ] = { { 'a', 'b' }, { 'c', 'd' } };
for ( int i = 0; i < MAX_ROWS; i++ )
for ( int j = 0; j < MAX_COLS; j++ )
cout << c[ i ][ j ] << endl;
}
正下标和负下标
数组的第一个元素是元素 0。 C++ 数组的范围从 数组[0] 到 数组[size - 1]。 但是，C++ 支持正负下标。 负下标必须在数组边界内；否则结果不可预知。 以下代码显示了正数组和负数组下标：
#include <iostream>
using namespace std;
int main()
{
int intArray[1024];
for (int i = 0, j = 0; i < 1024; i++)
{
intArray[i] = j++;
}
cout << intArray[512] << endl; // 512
cout << 257[intArray] << endl; // 257
int *midArray = &intArray[512]; // pointer to the middle of the array
cout << midArray[-256] << endl; // 256
cout << intArray[-256] << endl; // unpredictable, may crash
return 0 ;
}最后一行中的负下标可能会产生运行时错误，因为它指向内存中比数组原点低 256 int 个位置的地址。 指针被初始化到 的中间;因此， (对指针使用正) 负数组索引，这一点十分 midArray intArray 危险。 数组下标错误不会产生编译时错误，但它们会产生不可预知的结果。
下标运算符是可交换的。 因此，只要下标 运算符 未重载，表达式数组 [index] 和 index[array] 就保证等效 (重载运算符) 。 第一种形式是最常见的编码做法，但它们都有效。
4.3.13 其他
4.3.13.1 alignof运算符
alignof 运算符将指定类型的对齐方式返回为类型的值 size_t
alignof( type )
4.3.13.2 __uuidof 运算符
检索附加到表达式的 GUID。
__uuidof (表达式)
4.3.13.3 delete运算符
释放内存块。
[ :: ] delete cast-expression
[ :: ] delete [] cast-expression
3、new运算符
从免费存储为 类型 为的对象或对象数组分配内存，并将适当类型的非零指针返回到该对象。
[::] new [placement] new-type-name [new-initializer]
[::] new [placement] ( type-name ) [new-initializer]
4.3.13.4 二进制求补运算符：~
~ cast-expression
1的补数运算符 (~) ，有时称为 按位求补 运算符，产生其操作数的按位二进制反码。 即，操作数中为 1 的每个位在结果中为 0。 相反，操作数中为 0 的每个位在结果中为 1。 二进制反码运算符的操作数必须为整型。
4.3.13.5 指向成员的指针运算符：.* 和->*
expression .* expression
expression ->* expression
指向成员的指针运算符（. * 和->* ）返回表达式左侧指定的对象的特定类成员的值。 右侧必须指定该类的成员。
4.3.13.6 作用域解析运算符： ::
范围解析运算符 :: 用于标识和消除在不同范围内使用的标识符。
qualified-id:
nested-name-specifier template opt unqualified-id
nested-name-specifier:
::
type-name ::
namespace-name ::
decltype-specifier ::
nested-name-specifier identifier ::
nested-name-specifiertemplate opt simple-template-id::
unqualified-id:
identifier
operator-function-id
conversion-function-id
literal-operator-id
~ type-name
~ decltype-specifier
template-id
备注：identifier 可以是变量、函数或枚举值。
用于 :: 类和命名空间
用于 :: 静态成员：必须使用范围解析运算符来调用类的静态成员。
用于 :: 作用域枚举：作用域内的解析运算符也与范围枚举 枚举声明的值一起使用
4.3.13.7 typeid 运算符
typeid(type-id)
typeid(expression)
typeid 运算符允许运行时确定对象的类型。
2832
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
