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-specifier
template
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
运算符允许运行时确定对象的类型。