C++中的范围解析算子-yiteyi-C++库

在C++中，作用域解析操作符是 :: .它用于以下目的。

null

1）要在存在同名局部变量时访问全局变量，请执行以下操作：

                     // C++ program to show that we can access a global variable                   
                     // using scope resolution operator :: when there is a local                   
                     // variable with same name                   
                     #include<iostream>                   
                     using                               namespace                               std;                   
                             
                     int                               x;                               // Global x                   
                             
                     int                               main()                   
                     {                   
                                         int                               x = 10;                               // Local x                   
                                         cout <<                               "Value of global x is "                               << ::x;                   
                                         cout <<                               "Value of local x is "                               << x;                   
                                         return                               0;                   
                     }                   

输出：

Value of global x is 0
Value of local x is 10

2）在类之外定义函数。

                     // C++ program to show that scope resolution operator :: is used                   
                     // to define a function outside a class                   
                     #include<iostream>                   
                     using                               namespace                               std;                   
                             
                     class                               A                   
                     {                   
                     public                               :                   
                             
                                         // Only declaration                   
                                         void                               fun();                   
                     };                   
                             
                     // Definition outside class using ::                   
                     void                               A::fun()                   
                     {                   
                                         cout <<                               "fun() called"                               ;                   
                     }                   
                             
                     int                               main()                   
                     {                   
                                         A a;                   
                                         a.fun();                   
                                         return                               0;                   
                     }                   

输出：

fun() called

3）访问类的静态变量。

                     // C++ program to show that :: can be used to access static                   
                     // members when there is a local variable with same name                   
                     #include<iostream>                   
                     using                               namespace                               std;                   
                             
                     class                               Test                   
                     {                   
                                         static                               int                               x;                   
                     public                               :                   
                                         static                               int                               y;                   
                             
                                         // Local parameter 'a' hides class member                   
                                         // 'a', but we can access it using ::                   
                                         void                               func(                               int                               x)                   
                                         {                   
                                         // We can access class's static variable                   
                                         // even if there is a local variable                   
                                         cout <<                               "Value of static x is "                               << Test::x;                   
                             
                                         cout <<                               "Value of local x is "                               << x;                   
                                         }                   
                     };                   
                             
                     // In C++, static members must be explicitly defined                   
                     // like this                   
                     int                               Test::x = 1;                   
                     int                               Test::y = 2;                   
                             
                     int                               main()                   
                     {                   
                                         Test obj;                   
                                         int                               x = 3 ;                   
                                         obj.func(x);                   
                             
                                         cout <<                               "Test::y = "                               << Test::y;                   
                             
                                         return                               0;                   
                     }                   

输出：

Value of static x is 1
Value of local x is 3
Test::y = 2;

4）如果是多重继承： 如果两个祖先类中存在相同的变量名，我们可以使用范围解析运算符来区分。

                     // Use of scope resolution operator in multiple inheritance.                   
                     #include<iostream>                   
                     using                               namespace                               std;                   
                             
                     class                               A                   
                     {                   
                     protected                               :                   
                                         int                               x;                   
                     public                               :                   
                                         A() { x = 10; }                   
                     };                   
                             
                     class                               B                   
                     {                   
                     protected                               :                   
                                         int                               x;                   
                     public                               :                   
                                         B() { x = 20; }                   
                     };                   
                             
                     class                               C:                               public                               A,                               public                               B                   
                     {                   
                     public                               :                   
                                         void                               fun()                   
                                         {                   
                                         cout <<                               "A's x is "                               << A::x;                   
                                         cout <<                               "B's x is "                               << B::x;                   
                                         }                   
                     };                   
                             
                     int                               main()                   
                     {                   
                                         C c;                   
                                         c.fun();                   
                                         return                               0;                   
                     }                   

输出：

A's x is 10
B's x is 20

5）用于命名空间 如果两个名称空间中存在同名的类，我们可以使用名称空间名称和范围解析运算符来引用该类，而不会产生任何冲突

                     // Use of scope resolution operator for namespace.                   
                     #include<iostream>                   
                             
                             
                     int                               main(){                   
                                         std::cout <<                               "Hello"                               << std::endl;                   
                             
                     }                   

Here, cout and endl belong to the std namespace.

6）在另一个类中引用一个类： 如果一个类存在于另一个类中，我们可以使用嵌套类来使用范围解析操作符引用嵌套类

                     // Use of scope resolution class inside another class.                   
                     #include<iostream>                   
                     using                               namespace                               std;                   
                             
                     class                               outside                   
                     {                   
                     public                               :                   
                                         int                               x;                   
                                         class                               inside                   
                                         {                   
                                         public                               :                   
                                         int                               x;                   
                                         static                               int                               y;                   
                                         int                               foo();                   
                             
                                         };                   
                     };                   
                     int                               outside::inside::y = 5;                   
                             
                     int                               main(){                   
                                         outside A;                   
                                         outside::inside B;                   
                             
                     }                   

如果您发现任何不正确的地方，或者您想分享有关上述主题的更多信息，请写评论

文章版权归作者所有，未经允许请勿转载。

THE END

技术文章