作用域运算符

  • global scope(全局作用域符），用法（::name)

  • class scope(类作用域符），用法(class::name)

  • namespace scope(命名空间作用域符），用法(namespace::name)

他们的作用都是为了更明确的调用你想要的变量。:: 如果前面有东西那么一定是命名空间名或者是类名。

  1. #include <iostream>
  3. using namespace std;
  5. int count = 0;
  7. struct FHello {
  8.     static const int count = 10;
  9. };
  11. void main() {
  12.     int count = 20;
  14.     cout << count << endl;
  15.     cout << ::count << endl;
  16.     cout << FHello::count << endl;
  17. }
  19. // 20
  20. // 10
  21. // 0

相当于在类的定义里定义一个静态变量/函数，那么这个变量就属于这个类了，需要加上 :: 才可以访问到。或者通过对象来访问也可以。编译器编译时，全部会替换类名调用。

  1. #include <iostream>
  2. using namespace std;
  4. struct FHello {
  5.     static void hello() {
  6.         cout << "213" << endl;
  7.     };
  8.     static const int count = 10;
  9. };
  11. int main() {
  12.     FHello Hello;
  13.     Hello.hello();
  14.     cout << Hello.count << endl;
  15. }

作用域也是有当前作用域的，例如在类中可以忽略 FHello::a 来访问 a 。

  1. struct FHello {
  2.     static int hello() {
  3.         return a + b;
  4.     };
  5.     static int a;
  6.     static int b;
  7. };

通过类名来定义指针

  1. struct Student {
  2.   int a;
  3.   int b;
  4.   float c;
  5. }
  7. int main() {
  8.   Student wang {1, 2, 3.0};
  9.   int Student::*p = &Student::a;
  11.   wang.*p = 1;
  12.   return 0;
  13. }

看一个指针指向什么要看解引用后表示什么东西，p 解引用后表示 Student 类型中的 int 成员，因此 p 指向的是 Student 类中的 int 成员。

类似的有 int (*q)[5]q 解引用后表示长度为 5 的 int 数组。

菱形继承中的 ::

上面讲的主要是静态变量/函数，接下来我们看 :: 在普通成员中的使用。

  1. #include <iostream>
  2. using namespace std;
  4. class A {
  5. public:
  6.     int m_a = 1;
  7. };
  9. class B :public A {
  10. public:
  11.     int m_b;
  12. };
  14. class C :public A {
  15. public:
  16.     int m_c;
  17. };
  19. class D :public B, public C {
  20. public:
  21.     void hello() {
  22.         cout << B::m_a << endl;
  23.     }
  24. };
  26. int main() {
  27.     D d;
  28.     d.hello();
  29.     return 0;
  30. }

使用 :: 来解决继承中的冲突。