精华内容
下载资源
问答
  • 演示了 Docker 虚拟化的基础技术之一:Linux NameSpace。 2015/04/26 @ 泰晓沙龙 第二期
  • 通过使用网络名称空间执行单个进程的网络跟踪。 该应用程序使用Linux网络名称空间来执行单个应用程序的网络跟踪。 跟踪将另存为pcap文件。 以后可以通过Wireshark或tshark进行分析。 该nsntrace应用在很大程度上...
  • C++名字空间详解

    千次阅读 2018-04-25 14:41:32
    1.名字空间的由来名字空间(namespace)是由标准C++引入的,是一种新的作用域级别。原来C++标识符的作用域分为三级:代码块({…}和函数体)...2.名字空间的作用名字空间的作用主要是为了解决日益严重的名称冲突问...

    1.名字空间的由来

    名字空间(namespace)是由标准C++引入的,是一种新的作用域级别。原来C++标识符的作用域分为三级:代码块({…}和函数体)、类域和全局作用域。如今,在类作用域和全局作用域之间,C++标准又添加了名字空间域这一个作用域级别。

    命名空间是ANSIC++引入的可以由用户命名的作用域,用来处理程序中常见的同名冲突。

    2.名字空间的作用

    名字空间的作用主要是为了解决日益严重的名称冲突问题。随着可重用代码的增多,各种不同的代码体系中的标识符之间同名的情况就会显著增多。解决的办法就是将不同的代码库放到不同的名字空间中。

    访问一个具体的标识符的时候,可以使用如下形式:space_name::identifier。即用作用域指示符“::”将名字空间的名称和该空间下的标识符连接起来,这要,即使使用同名的标识符,由于它们处于不同的名字空间,也不会发生冲突。

    有两种形式的命名空间——有名的和无名的。 
    定义格式为:

    有名的命名空间:
           namespace 命名空间名 {
                  声明序列可选
           }
    匿名的命名空间:
           namespace {
                  声明序列可选
           }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3.名字空间的注意要点

    (1)一个名字空间可以在多个头文件或源文件中实现,成为分段定义。如果想在当前文件访问定义在另一个文件中的同名名字空间内的成员变量,需要在当前文件的名字空间内部进行申明。如标准C++库中的所有组件都是在一个被称为std的名字空间中声明和定义的。这些组件当然分散在不同的头文件和源文件中。

    (2)名字空间内部可以定义类型、函数、变量等内容,但名字空间不能定义在类和函数的内部。

    (3)在一个名字空间中可以自由地访问另一个名字空间的内容,因为名字空间并没有保护级别的限制。

    (4)虽然经常可以见到using namespace std;这样的用法,我们也可以用同样的方法将名字空间中的内容一次性“引入”到当前的名字空间中来,但这并不是一个值得推荐的用法。因为这样做的相当于取消了名字空间的定义,使发生名称冲突的机会增多。所以,用using单独引入需要的内容,这样会更有针对性。例如,要使用标准输入对象,只需用using std::cin;就可以了。

    (5)不能在名字空间的定义中声明另一个嵌套的子命名空间,只能在命名空间中定义子命名空间。

    (6)名字空间的成员,可以在命名空间的内部定义,也可以在名字空间的外部定义,但是要在名字空间进行声明。 
    命名空间成员的外部定义的格式为:

    名字空间名::成员名 ……
    • 1

    (7)名字空间在进行分段定义时,不能定义同名的变量,否则连接出现重定义错误。因为名字空间不同于类,具有外部连接的特性。由于外部连接特性,请不要将名字空间定义在头文件,因为当被不同的源文件包含时,会出现重定义的错误。

    结合以上几点,观察如下程序。

    //main.cpp
    #include <iostream>
    
    namespace myspace1{
        extern int gvar;//内部声明
        extern int otherVar; //另一个文件中同名名字空间中定义
        using std::cout;
        using std::endl;
        class myclass{
        public:
            void print(){
                cout<<"in space1,gvar="<<gvar<<endl;
            }
        };
    }
    
    
    namespace myspace2{
        using std::cout;
        using std::endl;
        int i=5;
        class myclass{
        public:
            void print(){
                cout<<"in space2"<<endl;
            }
        };
        namespace nestedspace{
            void ExternFunc();//内部声明
        }
    }
    
    //外部定义
    int myspace1::gvar=1;
    void myspace2::nestedspace::ExternFunc()
    {
        cout<<"in nestedspace"<<endl;
    }
    
    int main(int argc,char* argv[])
    {
        myspace1::myclass obj1;
        obj1.print();
        myspace2::myclass obj2;
        obj2.print();
        myspace2::nestedspace::ExternFunc();
        std::cout<<myspace1::otherVar<<std::endl;
    
        getchar();
    }
    
    //sp2.cpp
    namespace myspace1{
        int otherVar=3;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55

    程序输出结果是: 
    这里写图片描述

    (8)为了避免命名空间的名字与其他的命名空间同名,可以用较长的标识符作为命名空间的名字。但是书写较长的命名空间名时,有些冗余,因此,我们可以在特定的上下文环境中给命名空间起一个相对简单的别名。 
    参考如下程序。

    namespace MyNewlyCreatedSpace{
        void show(){
            std::cout<<"a function within a namespace"<<std::endl;
        }
    }
    
    int main(int argc,char* argv[])
    {
        namespace sp=MyNewlyCreatedSpace;
        sp::show();
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    4.匿名名字空间

    4.1与static关键字的共同作用

    匿名名字空间提供了类似在全局函数前加 static 修饰带来的限制作用域的功能。它的这种特性可以被用在struct和class上, 而普通的static却不能。比如,在两个源文件中定义了相同的全局变量(或函数),就会发生重定义的错误。如果将它们声明为全局静态变量(函数)就可以避免重定义错误。在C++中,除了可以使用static关键字避免全局变量(函数)的重定义错误,还可以通过匿名名字空间的方式实现。参考如下代码。

    //main.cpp
    #include <iostream>
    using namespace std;
    
    namespace{
        double dvar=1.8;
    }
    void show1(){
        cout<<"dvar:"<<dvar<<endl;
    }
    
    int main(int argc,char* argv[])
    {
        void show2();
        show1();
        show2();
    }
    
    //a.cpp
    #include <iostream>
    using namespace std;
    
    double dvar=2.8;
    void show2(){
        cout<<"dvar:"<<dvar<<endl;
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    程序输出: 
    这里写图片描述

    未命名的名字空间中定义的变量(或函数)只在包含该名字空间的文件中可见,但其中的变量的生存期却从程序开始到程序结束。如果有多个文件包含未命名的名字空间,这些名字空间是不相关的,即使这些名字空间中定义了同名的变量(函数),这些标识符也代表不同的对象。

    4.2与static的不同

    通过匿名名字空间,同样实现了对不同源文件中同名全局变量(函数)的保护,使它们不至于发生冲一定冲突。在这一点上,匿名名字空间和static的作用是相同的。

    但是,用static修饰的变量(函数)具有内部连接特性,而具有内部连接特性的变量(函数)是不能用来实例化一个模板的。参考如下程序。

    #include <iostream>
    using namespace std;
    
    template <char*p> class Example{
    public:
        void display(){
            cout<<*p<<endl;
        }
    };
    
    static  char c='a';
    int main(int argc,char* argv[])
    {
    
        Example<&c> a; //编译出错
        a.display();
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    此程序无法通过编译,因为静态变量c不具有外部连接特性,因此不是真正的“全局”变量。而类模板的非类型参数要求是编译时常量表达式,或者是指针类型的参数要求指针指向的对象具有外部连接性。具体要求,参见C++标准关于模板非类型参数的要求:

    14.3.2 Template non-type arguments [temp.arg.nontype] 
    1 A template-argument for a non-type, non-template template-parameter shall be one of: 
    — an integral constant-expression of integral or enumeration type; or 
    — the name of a non-type template-parameter; or 
    — the address of an object or function with external linkage, including function templates and function 
    template-ids but excluding non-static class members, expressed as & id-expression where the & is 
    optional if the name refers to a function or array, or if the corresponding template-parameter is a reference; 
    or 
    — a pointer to member expressed as described in 5.3.1 .

    C++11标准文档的下载见C++11标准文档下载,或者到官网下载:ISO相关标准官网

    为了实现既能保护全局变量(函数)不受重定义错误的干扰,能够使它们具有外部连接特性的目的,必须使用匿名名字空间机制。同样是上面的这个程序,将char c=’a’;至于匿名空间进行定义,即可通过编译并运行。读者可自行考证。

    通过以上程序,可以看出匿名名字空间与static的区别:包含在匿名名字空间中的全局变量(函数)具有外部连接特性,而用static修饰的全局变量具有内部连接特性,不能用来实例化模板的非类型参数。


    展开全文
  •  名字空间内的名字可以被该名字空间内的其他成员直接访问,名字空间外的代码必须指定该名字位于哪个名字空间。  一个名字空间可以包含多种类型的标识符,如下面所列:  变量、常量、函数、结构体/联合体/枚举、...
  • Python 名称空间与作用域

    千次阅读 2018-01-20 08:51:46
    这篇文章介绍 Python 的名称空间以及变量的作用域。 Python 的名称 Python 的名称(Name)是对象的一个标识(Identifier)。我们知道,在 Python 里面一切皆对象,名称就是用来引用对象的。说得有点玄乎,我们以...

    这篇文章介绍 Python 的名称空间以及变量的作用域。

    Python 的名称

    Python 的名称(Name)是对象的一个标识(Identifier)。我们知道,在 Python 里面一切皆对象,名称就是用来引用对象的。说得有点玄乎,我们以例子说明。

    例如,在a = 2这个语句中,2是个存储在内存中的一个对象,名称a则会引用2这个对象,“引用”的含义是指可以通过名称a来使用2这个对象。我们可以使用id()函数来获取对象的地址。

    a = 2
    print(id(2))
    print(id(a))

    输出:

    43547988
    43547988

    可以看到,两都均指向同一个对象。我们再来看复杂一点的代码。

    a = 2
    print 'id(a) = %s' % id(a)
    a = a + 1
    print 'id(a) = %s' % id(a)
    print 'id(3) = %s' % id(3)
    b = 2
    print 'id(2) = %s' % id(2)
    print 'id(b) = %s' % id(b)

    输出:

    id(a) = 55606612
    id(a) = 55606600
    id(3) = 55606600
    id(2) = 55606612
    id(b) = 55606612

    上述的代码发生了什么呢?我们以图1来说明。


    图1:Python 的名称与对象

    起初,名称a引用对象2
    然后,执行操作a = a + 1,这时对象3被创建,名称a引用对象3,所以id(a)id(3)输出相同的地址;
    最后,执行b = 2,名称b引用对象2,所以id(2)id(b)输出相同的地址

    这个例子也展示了 Python 在执行变量的赋值时,并不会重复创建一个对象的事实。名称采用动态绑定的机制使得 Python 更加高效,同一个名称可以引用不同类型的对象。

    a = 5
    a = 'hello world'
    a = [1, 2, 3]

    可以看到,a先后引用了数字,字符串,列表的类型的对象,这在 Python 中完全是合法的。

    Python 的名称空间

    了解 Python 的名称后,我们来看 Python 的名称空间。

    名称空间是名称到对象的映射。

    在 Python 中,名称空间采用字典来实现。Python 的名称空间包括:

    • 内置名称空间,例如,内置名称空间包含 Python 的内置函数,如,abs()
    • 模块名称空间,全局名称空间,在模块内定义的名称
    • 局部名称空间,例如,在函数(function)或者类(class)被调用时,其内部包含的名称

    不同的名称空间内的名称不会相互冲突,即是它们采用相同的名称。这也正是名称空间的作用。

    内置名称空间在 Python 解释器启动时就创建了,直到 Python 解释器退出时内置名称空间才失效。这使得我们可以在程序的任何位置使用内置名称空间内的名称,例如,id()print()等函数。
    模块名称空间当模块被引用时创建,直到 Python 解释器退出时模块名称空间才失效。
    函数名称空间在函数被调用时创建,函数返回后失效。


    图2:Python 的名称空间

    Python 变量的作用域

    Python 的作用域(scope)决定了我们在程序中能否直接使用名称空间中的名称,直接访问的意思是指不需要在名称前添加名称空间的前缀。对于 Python 来说,至少存在以下三类的作用域。

    • 函数作用域,包括了函数内的局部名称
    • 模块作用域,包括了模块内的全局名称
    • 内置作用域,包括了内置名称

    当在函数内部使用一个名称时,为了查找出该名称所引用的对象,Python 解释器先在函数名称空间查找,接着在模块名称空间查找,最后在内置名称空间查找,直到寻找到该名称为止。
    当函数 A 处于函数 B 的内部时,函数 A 的作用域处于函数 B 作用域之内。

    例子

    def outer_function():
        b = 20
        def inner_func():
            c = 30
    
    a = 10

    在这个例子中,名称a在全局名称空间中,名称b在函数outer_function的局部名称空间,名称c则在函数inner_func的局部名称空间。
    当我们在函数inner_func时,c是个局部的名称,b是个非局部的名称,而a则是个全局的名称。在函数inner_func中,我们可以对c进行读取操作和赋值操作,而只能对ba进行读取操作。当对b进行赋值时,一个新的名称将会被创建,这个新的名称处于inner_func函数局部名称空间中。对a进行赋值时也会在局部名称空间中创建一个新的名称。

    我们使用以下的例子来说明。

    def outer_function():
        a = 20
    
        def inner_function():
            a = 30
            print('a = %s' % a)
    
        inner_function()
        print('a = %s' % a)
    
    
    a = 10
    outer_function()
    print('a = %s' % a)

    输出:

    a = 30
    a = 20
    a = 10

    在函数inner_function中,我们对a进行了赋值操作,但函数outer_function中的a仍然为20,全局名称空间中的a则仍然为10

    为了在函数作用域中对全局的名称进行读取或者赋值操作,需要将这个名称声明为global

    def outer_function():
        global a
        a = 20
    
        def inner_function():
            global a
            a = 30
            print('a = %s' % a)
    
        inner_function()
        print('a = %s' % a)
    
    
    a = 10
    outer_function()
    print('a = %s' % a)

    输出:

    a = 30
    a = 30
    a = 30

    可以看到,通过global,我们在不同的作用域对全局名称a进行了赋值操作,最后在函数inner_function中对a的赋值也就是全局名称a的值。

    参考资料

    1. https://www.programiz.com/python-programming/namespace
    2. https://docs.python.org/3/tutorial/classes.html
    3. https://www.python-course.eu/namespaces.php
    4. https://www.python-course.eu/global_vs_local_variables.php
    5. https://www.programiz.com/python-programming/modules
    6. https://code.tutsplus.com/tutorials/what-are-python-namespaces-and-why-are-they-needed–cms-28598
    7. https://bytebaker.com/2008/07/30/python-namespaces/
    8. https://stackoverflow.com/questions/3190706/nonlocal-keyword-in-python-2-x
    展开全文
  • C++--名字空间的定义

    2019-11-04 17:02:54
    C++提供了一种称为**名字空间(namespace)**的机制,一方面表达某些声明是属于一个整体,另一方面表明它们的名字不会与其他名字空间中的名字冲突。 例如,我们尝试利用自己定义的"My_code"名字空间进行试验: ...

    C++提供了一种称为**名字空间(namespace)**的机制,一方面表达某些声明是属于一个整体,另一方面表明它们的名字不会与其他名字空间中的名字冲突。
    例如,我们尝试利用自己定义的"My_code"名字空间进行试验:

    namespace My_code{     //定义My_code名字空间
    	class complex{/*...*/};
    	complex sqrt(complex);
    	//...
    	int main();
    }
    int My_code::main(){  //这个main()函数隶属于上面自己定义的My_code名字空间的main()函数,
    	complex z{1,2};
    	auto z2 = sqrt(z);
    	std::cout<<'{'<<z2.real()<<','<<z2.image()<<"}\n";
    	//...
    }
    int main(){//这个main()函数不是My_code名字空间的main()函数,只是全局名字空间中的函数。
    	return My_code::main(); //这句代码表示回调My_code名字空间的main()函数,
    }
    

    通过将代码放在名字空间My_code中,就可以确保我们的名字不会和名字空间std中的标准库名字冲突。因为标准库确实支持complex算术运算,所以提前设置这样的预防措施是好的。
    要想访问其他名字空间中的某个名字,最简单的方法是在这个名字前加上名字空间的名字作为限定 ( 例如std:cout 和 My code:main)。 “真正的 main() ”定义在全局名字空间中,换句话说,它不属于任何自定义名字空间、类或函数。要想获取标准库名字空间中名字的访问权,我们应该使用using指示:
    using namespace std;
    名字空间主要用于组织较大规模的程序组件,最典型的例子是库。使用名字空间,我们就可以很容易地把若干独立开发的部件组织成一个程序。

    展开全文
  • 名称空间

    2014-04-27 17:25:31
    在C++中,名称

    在C++中,名称可以是变量、函数、结构、枚举、类以及类和结构的成员。

    1 传统的C++名称空间

    第一个需要知道的术语是声明区域。声明区域是可以在其中进行声明的区域。例如,可以在函数外面什么全局变量,对于这种变量,其声明区域为其声明所在的文件。对于在函数中声明的变量,其声明区域为其声明区域所在的代码块。
    第二个需要知道的术语是潜在作用域。变量的潜在作用域从声明点开始,到其声明区域的结尾。因此潜在作用域比声明区域小,这是由于变量必须定以后才能使用。
    然而,变量并非在其潜在作用域内的任何位置都是可见的。例如,它可能被另一个在嵌套声明区域中声明的同名变量隐藏。变量对程序而言可见的范围被称为作用域。

    2 新的名称空间特性

    C++新增了这样一种功能,即通过定义一种新的声明区域来创建命名的名称空间。这样做的目的之一是提供了一个声明名称的区域。一个名称空间中的名称不会与另外一个名称空间的相同名称发生冲突,同时允许程序的其他部分使用该名称空间中声明的东西。
    例如:
    namespace Jack{
           double pail;
           void fetch();
            int pal;
            struct well{...};
    }
    namespace Jill{
            double bucket(double n){...};
            double fetch;
            int pal;
            struct Hill{...};
    }
    名称空间可以是全局的,也可以是位于另一个名称空间中,但不能位于代码块中。因此,在默认情况下,在名称空间中声明的名称的链接性为外部的(除非它引用了常量)。
    除了用户定义的名称空间外,还存在另一个名称空间——全局名称空间。它对应于文件级声明区域,因此前面所说的全局变量现在被描述为位于全局名称空间中。
    名称空间是开放的,即可以把名称加入到已有的名称空间中。例如
    namespace Jill{
          char *goose(const char*);
    }

    当然,需要有一种方法来访问给定名称空间中的名称。最简单的方法是,通过作用域解析运算符::,使用名称空间来限定该名称:
    Jack ::pail=12.34;
    Jill::Hill mole;
    Jack::fetch();

    未被装饰的名称(如pail)称为未限定的名称;包含名称空间的名称(如Jack::pail)称为限定的名称。

    1)using 声明和using编译指令
    我们并不希望每次使用名称时都对它进行限定,因此C++提供了两种机制(using声明和using编译指令)来简化对名称空间中名称的使用。using 声明使特定的标识符可用,using编译指令使整个名称空间可以。

    using声明由被限定的名称和它使用的关键字using组成:
    using Jill::fetch;

    using 声明将特定的名称添加到它所属的声明区域中。例如main()中的using声明Jill::fetch将fetch添加到main()定义的声明区域中。完成该声明后,便可以使用名称fetch代替Jill::fetch。下面的代码段说明了这几点:

    由于using声明将名称添加到局部声明区域中,因此这个示例避免了将另一个局部变量也命名为fetch。另外,和其他局部变量一样,fetch也将覆盖同名的全局变量。

    在函数外面使用using声明时,将被名称添加到全局名称空间中:


    using声明使一个名称可用,而using编译指令是所有的名称可用。using编译指令由名称空间名和他前面的关键字using namespace组成,它使名称空间中的所以名称都可用,而不需要使用作用域解析运算符:

    using namespace Jack;

    在全局声明区域中使用using编译指令,将使该名称空间的名称全局可用。

    在函数中使用using编译指令,将使其中的名称在该函数中可用。

    2)using编译指令和using声明之比较

    使用using编译指令导入仪名称空间中所有的名称与使用多个using声明是不一样的,而更像是大量使用作用域解析运算符。使用using声明时,就好像声明了相应的名称一样。如果某个名称已经在函数中声明了,则不能用using声明导入相同的名称。然而,使用using编译指令时,将进行名称解析,就像在包含using声明和名称空间本身的最小声明区域中声明了名称一样。在下面的示例中,名称空间为全局的。如果使用using编译指令导入一个已经在函数中声明的名称,则局部名称将隐藏名称空间名,就像隐藏同名的全局变量一样。不同仍可以像下面的示例那样使用作用域解析运算符;


    注意:假设名称空间和声明区域定义了相同的名称。如果试图使用using声明将名称空间的名称导入该声明区域,则这两个名称会发生冲突,从而出错。如果使用using编译指令将该名称空间的名称导入该声明区域,则局部版本将因此名称空间版本。

    一般说来,使用using声明比使用using编译指令更安全,这是由于它只导入指定的名称。如果该名称与局部名称发生冲突,编译器将发出指示。using编译指令导入所有的名称,包括可能并不需要的名称。如果与局部名称发生冲突,则局部名称将覆盖名称空间版本,而编译器并不会发生警告。另外,名称空间的开放意味着名称空间的名称可能分散在多个地方,这使得难以准确知道添加了哪些名称。
    #include<iostream>
    int main()
    {
    using namespace std;
    
    
    #include<iostream>
    using namespace std;
    int main(){
    
    
    int x;
    std::cin>>x;
    std::cout<<x<<std::endl;
    
    或者
    
    using std::cin;
    using std::cout;
    using std::endl;
    int x;
    cin>>x;
    cout<<x<<endl;
    

    3)名称空间的其他特性

    可以将名称空间声明进行嵌套:
    namespace elements
    {
           namespace fire
           {
               int flame;
               .....
             }
             float water;
    }

    这里,flame指的是elements::fire::flame。同样,可以使用下面的using编译指令使内部的名称可以:
    using namespace elements::fire;

    4)未命名的名称空间
    可以通过省略名称空间的名称来创建未命名的名称空间:

    namespace
    {
         int ice;
         int bandycoot;
    }

    这就像后面跟着using 编译指令一样,也就是说,在该名称空间中声明的名称的潜在作用域:从声明点到该声明区域末尾。从这方面看,它们与全局变量相似。然而,由于这种名称空间没有名称,因此不能显式地使用using编译指令或using声明来使用它在其他位置都可用。具体地说,不能在未命名名称空间所属文件之外的其他文件中,使用该名称空间的名称。这提供了链接性为内部的静态变量的替代品。例如:

    展开全文
  • HDFS名字空间(NameSpace)

    万次阅读 2020-10-12 20:40:36
    名字空间(NameSpace) 目标:掌握什么是“名字空间” HDFS 支持传统的层次型文件组织结构。用户或者应用程序可以创建目录,然后将文件保存在这些目录里。文件系统名字空间的层次结构和大多数现有的文件系统类似:...
  • C++之名字空间与类

    千次阅读 2018-08-16 18:54:00
    名字空间  把全局的命名空间进行分割,可以创建一个个独立的命名空间防止相互之间的冲突  C语言中的空间划分  全局、局部、块  定义名字空间的方式 namespace name {  ... }  名字空间的合并  同名的名字...
  • 为了避免,在大规模程序的设计中,以及在程序员使用各种各样的C++库时,这些标识符的命名发生冲突,标准C++引入了关键字namespace(命名空间/名字空间/名称空间/名域),可以更好地控制标识符的作用域。 MFC中并...
  • Docker的名称空间

    万次阅读 2020-10-26 22:48:10
    lrwxrwxrwx 1 1000 1000 0 Oct 26 22:24 user -> user:[4026531837] lrwxrwxrwx 1 1000 1000 0 Oct 26 22:24 uts -> uts:[4026532161] 这里可以查看到几大名称空间, 3、通过进入名称空间就可以查看到了: nsenter ...
  • 名字空间定义 名字空间使用 头源分离 同一命名空间在多个文件中  一般自己是不会使用的,但一些大型的库可能用到,比如命名空间std. 名字空间定义 解决名字冲突问题的究极解决方法:namespace(名字空间) ...
  • C++头文件名与名称空间

    千次阅读 2017-02-17 23:06:30
    1.头文件名 像iostream这样的文件叫做包含文件(include file)...C语言的传统是,头文件使用扩展名.h,将其作为一种通过名称标识文件类型的简单方式。例如,头文件math.h支持各种C语言数学函数,但C++的用法变了。
  • c++ 名称空间

    千次阅读 2018-05-27 10:36:07
    1.定义namespace 名称空间名{ 变量类型 变量; 函数返回值类型 函数原型;... 名称空间名 :: 函数名namespace 是C++中的一个新的特性,它的出现只要是为了避免出现名字污染。JAVA语言中的packing包和C++的name...
  • Kubernetes的两个Service(ServiceA、ServiceB)和对应的Pod(PodA、PodB)分别属于不同的namespace名称空间,现需要PodA和PodB跨namespace名称空间并通过Service实现互访。应该如何实现?
  • C++名称空间

    千次阅读 2017-05-31 21:46:11
    关于一般名称的特点,右转博文:引入名称空间之前C++变量和函数的存储方案及特点 —————————————————————————————————————————————————————————     ...
  • 文章目录一、名称空间1、内置名称空间2、全局名称空间3、局部名称空间二、作用域1、作用域与名字查找的优先级2、LEGB(四种名称空间)3、global关键字4、nonlocal关键字 一、名称空间 首先我们应该知道,栈一般存...
  • C# 中名称空间的引用

    千次阅读 热门讨论 2015-01-03 10:06:18
    什么是名称空间?        名称空间是.net 中提供应用程序代码容器的方式,类似jave中的包。  名称空间的目的就是为了让引用更加准确。就像哪一栋教学楼、哪一层、哪一房间,确定唯一的标识代码及其内容。 ...
  • C# 名称空间的别名

    千次阅读 2015-12-11 18:49:44
    我们知道 C 和 C++ 也把 #include 语句放在这里,所以从 C++迁移到 C# 的程序员把名称空间与 C++ 风格的头文件相混淆。其实 using 语句在这些文件之间并没有建立物理链接。C# 也没有对应 C++ 头文件的部分。using 和...
  • c++名字空间指令与名字空间声明

    千次阅读 2014-04-21 16:56:46
    在使用任何名字空间之前,编译器必须能够找到他,即确定他的声明所在的作用域。使用某个名字空间中的名字最简单的方式就是使用限定名字,即把名字空间的名字(如numeric)作为前缀,然后加上作用域操作符(::)。  ...
  • 文章目录一、名称空间1、内置名称空间2、全局名称空间3、局部名称空间二、作用域1、作用域与名字查找的优先级2、LEGB(四种名称空间)3、global关键字4、nonlocal关键字 一、名称空间 首先我们应该知道,栈一般存...
  • 载入了名字空间‘ellipsis’ 0.3.1,但需要的是>= 0.3.2 粗暴的解决方法 找到报错的包的名字,如我的例子中是ellipsis, 直接到Rstudio 右下角的框的Package栏,右边 x图标 remove它,再在console 控制台install.
  • 简单理解一下报错语句的意思就是载入的cli包的版本是2.3.0,但是实际要求的包的版本是2.4.0。两者之间并不匹配,产生冲突,于是在运行的过程中报错。 那这个时候,我预想的解决方法就是,更新cli包。...
  • 1.创建名字空间 直接在.h文件中输入 namespace WorkStation { namespace Trade { } } 这样就会创建名字空间了。 相应的在左侧的“类视图”中,就会看到该名字空间。 2. 将一个类添加到一个名字空间中。 直接在该...
  • C++ 命名空间,也有叫名称空间

    万次阅读 2020-12-06 23:10:29
    为了避免在大规模程序设计中,以及在程序员使用各种各样的C++库时,这些标识符的命名发生冲突,标准C++引入了关键字namespace(命名空间/名字空间/名称空间/名域),可以更好地控制标识符的作用域。 std是c++标准命名...
  • 问题 # Error: package or namespace load failed for ...# 载入了名字空间‘rlang’ 0.4.5,但需要的是>= 0.4.6 # install.packages("https://cran.r-project.org/src/contrib/Archive/rlang/rlang_
  • XML命名空间详解

    千次阅读 多人点赞 2019-08-09 10:26:06
    一、命名空间的意义 XML是一种非常好用的标记语言,它具有极好的可扩展性,因此当我们需要同时访问多份XML文档时,有可能会出现这样一种情况:在同一份XML文档中可能出现多个同名的标签和属性,而这些标签和属性意义...
  • 分布式文件系统名字空间实现研究

    万次阅读 热门讨论 2010-11-07 18:57:00
    名字空间(Namespace)即文件系统文件目录的组织方式,是文件系统的重要组成部分,为用户提供可视化的、可理解的文件系统视图,从而解决或降低人类与计算机之间在数据存储上的语义间隔。目前树状结构的文件系统组织...
  • p名称空间与C名称空间简化属性赋值 Spring给我们提供的一种比较简便的方式来为我们的属性赋值 P名称空间用于简化set方法的属性赋值 C名称空间用于简化构造器的属性赋值 第一步:加上我们的P名称空间与C名称空间 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,344,753
精华内容 537,901
关键字:

名称空间