c++中双引号的有什么作用

最新推荐文章于 2024-07-10 08:55:06 发布

慢慢的踏实走

最新推荐文章于 2024-07-10 08:55:06 发布

阅读量7.2k

点赞数

分类专栏： c++与面向对象

c++与面向对象专栏收录该内容

5 篇文章 0 订阅

订阅专栏

C++ 双冒号开头的语法是什么意思？

2015-01-15 14:30 sapient_82 | 浏览 229 次

编程语言软件

namespace IceDelegateM
{

namespace Demo
{

class Hello : virtual public ::IceDelegate::Demo::Hello,
              virtual public ::IceDelegateM::Ice::Object
{
public:

    virtual void sayHello(const ::Ice::Context*, ::IceInternal::InvocationObserver&);
};

}

}

我知道：：开头可以代表全局的意思，但我理解是可以在方法和变量的前面，表示是全局方法或是全局变量。但上面的代码里，：：是在命名空间或类名前，后面并不是跟方法或变量。例如：“class Hello : virtual public ::IceDelegate::Demo::Hello”

我有更好的答案

举报| 2015-01-15 14:41 网友采纳

命名空间限定。
std::string 
表示std命名空间下的 string类。
直接::开始，表示顶层命名空间（全局变量）std::string -> ::std::string 这样也可以。
::和 文件路径的 / 可以对照理解。

linux下面没有盘符之分。  只有一个盘，所以也就没有C,D,E,F这种了。
/usr/share/abc.txt            abc.txt 位于 /usr/share目录下
/abc.txt                           abc.txt直接位于硬盘下。第一个/就代表硬盘根目录。

追问：

：：开头如果是全局变量或函数的话，后面应该跟着变量或函数。但是上面的例子后面跟的是域名或类名，我觉得不应该是全局的意思。
你说的代表着根目录，到是有些像，可以这样理解吗？

追答：

如果函数放在全局，就是全局函数
如果变量定义在全局，就是全局变量
如果一个命名空间放在全局，就是全局命名空间。

std是一个全局命名空间  ios是一个内部命名空间（位于std下）
所以引用方式如下
::std::ios::ostream
::std::string

当没有冲突的时候，全局的::（也就是第一个）可以省略






C++11 tuple
      
      
      
      
       
       
        
        tuple元组定义了一个有固定数目元素的容器,其中的每个元素类型都可以不相同,这与其他容器有着本质的区别.是对pair的泛化。
        
        首先来介绍元组的创建和元组元素的访问。通过make_tuple()创建元组，通过get<>()来访问元组的元素。通过下面这段程序来认识这两个函数的用法：
        
        #include <iostream>
        
        #include <tuple>
        
        #include <functional>
        
         
        
        int main()
        
        {
        
            auto t1 = std::make_tuple(10, "Test", 3.14);
        
            std::cout << "The value of t1 is "
        
                      << "(" << std::get<0>(t1) << ", " << std::get<1>(t1)
        
                      << ", " << std::get<2>(t1) << ")\n";
        
         
        
            int n = 1;
        
            auto t2 = std::make_tuple(std::ref(n), n);//ref表示引用
        
            n = 7;
        
            std::cout << "The value of t2 is "
        
                      << "(" << std::get<0>(t2) << ", " << std::get<1>(t2) << ")\n";
        
        }
        
        运行结果为：
        
        The value of t1 is (10, Test, 3.14)
        
        The value of t2 is (7, 1)
        
         
        
        接下来介绍tie()函数。 tie()函数可以将变量连接到一个给定的tuple上，生成一个元素类型全是引用的tuple,相当于make_tuple(ref(a),ref(b),…)。可以通过tie()函数的使用方便的对tuple进行“解包”操作。看下面的代码：
        
        #include <iostream>
        
        #include <tuple>
        
         
        
        int main ()
        
        {
        
          int myint;
        
          char mychar;
        
          float myfloat;
        
         
        
          std::tuple<int,float,char> mytuple;
        
         
        
          mytuple = std::make_tuple (10, 2.6, 'a');          // packing values into tuple
        
         
        
          //std::tie (myint, std::ignore, mychar) = mytuple;   // unpacking tuple into variables  【1】
        
          std::tie (myint,myfloat, mychar) = mytuple;
        
         
        
          std::cout << "myint contains: " << myint << std::endl;
        
          std::cout << "mychar contains: " << mychar << std::endl;
        
          std::cout << "myfloat contains: "<< myfloat <<std::endl;
        
         
        
          std::get<0>(mytuple) = 100;//修改tuple的值
        
         
        
          std::cout <<"After assignment myint contains: "<< std::get<0>(mytuple) << std::endl;
        
         
        
          return 0;
        
        }
        
        运行结果：
        
        myint contains: 10
        
        mychar contains: a
        
        myfloat contains: 2.6
        
        After assignment myint contains: 100
        
        注：正如【1】处我们可以使用std::ignore,从而不用关联tuple中的第二个元素.
        
         
        
        最后介绍一个tuple_cat()函数，通过该函数可以将多个tuple连接起来形成一个tuple（注：在VC11中只能连接两个tuple并不是真正的多个tuple）。
        
        #include <iostream>
        
        #include <utility>
        
        #include <string>
        
        #include <tuple>
        
         
        
        int main ()
        
        {
        
         
        
          std::tuple<float,std::string> mytuple (3.14,"pi");
        
          std::pair<int,char> mypair (10,'a');
        
         
        
          auto myauto = std::tuple_cat ( mytuple, mypair );
        
         
        
          std::cout << "myauto contains: " << std::endl;
        
          std::cout << std::get<0>(myauto) << std::endl;
        
          std::cout << std::get<1>(myauto) << std::endl;
        
          std::cout << std::get<2>(myauto) << std::endl;
        
          std::cout << std::get<3>(myauto) << std::endl;
        
         
        
          return 0;
        
        }
        
        运行结果：
        
         
        
        myauto contains:
        
        3.14
        
        pi
        
        10
        
        a
       
       
       
       
        
        make it simple, make it happen
       
       
      
      
1、

 

作用域符号::的前面一般是类名称，后面一般是该类的成员名称，C++为例避免不同的类有名称相同的成员而采用作用域的方式进行区分
如：A,B表示两个类，在A,B中都有成员member。那么
      A::member就表示类A中的成员member
      B::member就表示类B中的成员member

 

2、

 

全局作用域符号：当全局变量在局部函数中与其中某个变量重名，那么就可以用::来区分如：

char    zhou;    //全局变量

void    sleep（）

｛

      char    zhou;    //局部变量

      char(局部变量) = char(局部变量) *char(局部变量) ; 

     ::char(全局变量) =::char(全局变量) *char(局部变量);

｝

 

3、

 

::是C++里的“作用域分解运算符”。比如声明了一个类A，类A里声明了一个成员函数voidf()，但没有在类的声明里给出f的定义，那么在类外定义f时，就要写成voidA::f()，表示这个f()函数是类A的成员函数。例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class CA { 
public: 
  int ca_var; 
  int add(int a, int b); 
  int add(int a); 
};
 
//那么在实现这个函数时，必须这样书写： 
int CA::add(int a, int b) 
{ 
  return a + b; 
} 
 
//另外，双冒号也常常用于在类变量内部作为当前类实例的元素进行表示，比如: 
int CA::add(int a) 
{ 
  return a + ::ca_var; 
}
 
//表示当前类实例中的变量ca_var。