精华内容
下载资源
问答
  • 命名空间的一
    2021-03-16 07:59:52

            使用命名空间的目的是对标识符的名称进行本地化,以避免命名冲突。在C++中,变量、函数和类都是大量存在的。如果没有命名空间,这些变量、函数、类的名称将都存在于全局命名空间中,会导致很多冲突。比如,如果我们在自己的程序中定义了一个函数toupper(),这将重写标准库中的toupper()函 数,这是因为这两个函数都是位于全局命名空间中的。命名冲突还会发生在一个程序中使用两个或者更多的第三方库的情况中。此时,很有可能,其中一个库中的名称和另外一个库中的名称是相同的,这样就冲突了。这种情况会经常发生在类的名称上。比如,我们在自己的程序中定义了一个Stack类,而我们程序中使用的某个库中也可能定义了一个同名的类,此时名称就冲突了。

      Namespace 关键字的出现就是针对这种问题的。由于这种机制对于声明于其中的名称都进行了本地化,就使得相同的名称可以在不同的上下文中使用,而不会引起名称的冲突。或许命名空间最大的受益者就是C++中的标准库了。在命名空间出现之前,整个C++库都是定义在全局命名空间中的(这当然也是唯一的命名空间)。引入命名空间后,C++库就被定义到自己的名称空间中了,称之为std。这样就减少了名称冲突的可能性。我们也可以在自己的程序中创建自己的命名空间,这样可以对我们认为可能导致冲突的名称进行本地化。这点在我们创建类或者是函数库的时候是特别重要的。

    命名空间基础

      namespace 关键字使得我们可以通过创建作用范围来对全局命名空间进行分隔。本质上来讲,一个命名空间就定义了一个范围。定义命名空间的基本形式如下:

      namespace 名称{//声明}

      在命名空间中定义的任何东西都局限于该命名空间内

      下面就是一个命名空间的例子,其中对一个实现简单递减计数器的类进行了本地化。在该命名空间中定义了计数器类用来实现计数;其中的upperbound和lowerbound用来表示计数器的上界和下界。

    ///演示命名空间
    namespace CounterNameSpace
    {
        int upperbound;
        int lowerbound;
        class counter
        {
        int count;
        public:
            counter(int n)
            {
                if ( n <= upperbound ){
                    count = n;
                } else  {
                    count = upperbound;
                }
            }
            void reset(int n)
            {
                if ( n < upperbound )
                {
                    count = n;
                }
            }
            int run() {
                if ( count > lowerbound)
                {
                    return count--;
                } else {
                    return lowerbound;
                }
            }
        };
    }

      其中的upperbound,lowerbound和类counter都是有命名空间CounterNameSpace定义范围的组成部分。

      在命名空间中声明的标识符是可以被直接引用的,不需要任何的命名空间的修饰符。例如,在CounterNameSapce命名空间中,run()函数中就可以直接在语句中引用lowerbound:

    ///在命名空间中使用变量
    if ( count > lowerbound)
    {
        return count--;
    }

      然而,既然命名空间定义了一个范围,那么我们在命名空间之外就需要使用范围解析运算符来引用命名空间中的对象。例如,在命名空间CounterNameSpace定义的范围之外给upperbound赋值为10,就必须这样写:

      CounterNameSpace::upperbound = 10;

      或者在CounterNameSpace定义的范围之外想要声明一个counter类的对象就必须这样写:

      CounterNameSpace::counter obj;

      一般来讲,在命名空间之外想要访问命名空间内部的成员需要在成员前面加上命名空间和范围解析运算符

      下面的程序演示了如何使用CounterNameSpace这个命名空间:

    #include <iostream>
    using namespace std;
    namespace CounterNameSpace
    {
    int upperbound;
    int lowerbound;
    
    class counter
    {
        int count;
    public:
        counter(int n)
        {
            if ( n <= upperbound )
            {
                count = n;
            }
            else
            {
                count = upperbound;
            }
        }
        void reset(int n)
        {
            if ( n < upperbound )
            {
                count = n;
            }
        }
        int run()
        {
            if ( count > lowerbound)
            {
                return count--;
            }
            else
                return lowerbound;
        }
    };
    }
    
    int main()
    {
        CounterNameSpace::upperbound = 100;
        CounterNameSpace::lowerbound = 0;
        CounterNameSpace::counter ob1(10);
        int i;
        do
        {
            i = ob1.run();
            cout << i << " ";
        }
        while (i > CounterNameSpace::lowerbound);
        cout << endl;
        CounterNameSpace::counter ob2(20);
        do
        {
            i = ob2.run();
            cout << i << " ";
        }
        while (i > CounterNameSpace::lowerbound);
    
        cout << endl;
        ob2.reset(100);
        do
        {
            i = ob2.run();
            cout << i << " ";
    
        }
        while (i > CounterNameSpace::lowerbound);
        cout << endl;
        return 0;
    }

      请注意:counter类以及upperbound和lowerbound的引用都是在前面加上了CounterNameSpace修饰符。但是,一旦声明了counter类型的对象,就没有必须在对该对象的任何成员使用这种修饰符了。因此ob1.run()是可以被直接调用的。其中的命名空间是可以被解析的。

      相同的空间名称是可以被多次声明的,这种声明向相互补充的。这就使得命名空间可以被分割到几个文件中甚至是同一个文件的不同地方中。例如:

    namespace NS
    {
        int i;
    }
    
    //...
    namespace NS
    {
        int j;
    }

      其中命名空间NS被分割成两部分,但是两部分的内容却是位于同一命名空间中的。也就是NS。最后一点:命名空间是可以嵌套的。也就是说可以在一个命名空间内部声明另外的命名空间。

    using关键字

      如果在程序中需要多次引用某个命名空间的成员,那么按照之前的说法,我们每次都要使用范围解析符来指定该命名空间,这是一件很麻烦的事情。为了解决这个问题,人们引入了using关键字。using语句通常有两种使用方式:

      using namespace 命名空间名称;

      using 命名空间名称::成员;

      第一种形式中的命名空间名称就是我们要访问的命名空间。该命名空间中的所有成员都会被引入到当前范围中。也就是说,他们都变成当前命名空间的一部分了,使用的时候不再需要使用范围限定符了。第二种形式只是让指定的命名空间中的指定成员在当前范围中变为可见。我们用前面的CounterNameSpace来举例,下面的using语句和赋值语句都是有效的:  

    using CounterNameSpace::lowerbound; //只有lowerbound当前是可见的
    lowerbound = 10; //这样写是合法的,因为lowerbound成员当前是可见的
    using CounterNameSpace; //所有CounterNameSpace空间的成员当前都是可见的
    upperbound = 100; //这样写是合法的,因为所有的CounterNameSpace成员目前都是可见的

    下面是我们对之前的程序进行修改的结果:

    ///使用using
    #include <iostream>
    using namespace std;
    namespace CounterNameSpace
    {
        int upperbound;
        int lowerbound;
        class counter
        {
            int count;
        public:
            counter(int n)
            {
                if ( n < upperbound)
                {
                    count = n;
                }
                else
                {
                    count = upperbound;
                }
            }
            void reset( int n )
            {
                if ( n <= upperbound )
                {
                    count = n;
                }
            }
            int run()
            {
                if ( count > lowerbound )
                {
                    return count--;
                }
                else
                {
                    return lowerbound;
                }
            }
        };
    }
    int main()
    {
        //这里只是用CounterNameSpace中的upperbound
        using CounterNameSpace::upperbound;
        //此时对upperbound的访问就不需要使用范围限定符了
        upperbound = 100;
        //但是使用lowerbound的时候,还是需要使用范围限定符的
        CounterNameSpace::lowerbound = 0;
        CounterNameSpace::counter ob1(10);
        int i;
        do
        {
            i = ob1.run();
            cout << i << " ";
        }while( i > CounterNameSpace::lowerbound);
        cout << endl;
        //下面我们将使用整个CounterNameSpace的命名空间
        using namespace CounterNameSpace;
        counter ob2(20);
        do
        {
            i = ob2.run();
            cout << i << " ";
        }while( i > CounterNameSpace::lowerbound);
        cout << endl;
        ob2.reset(100);
        lowerbound = 90;
        do
        {
            i = ob2.run();
            cout << i << " ";
        }while( i > lowerbound);
        return 0;
    }

    上面的程序还为我们演示了重要的一点:当我们用using引入一个命名空间的时候,如果之前有引用过别的命名空间(或者同一个命名空间),则不会覆盖掉对之前的引入,而是对之前引入内容的补充。也就是说,到最后,上述程序中的std和CounterNameSpace这两个命名空间都变成全局空间了。

    没有名称的命名空间

    有一种特殊的命名空间,叫做未命名的命名空间。这种没有名称的命名空间使得我们可以创建在一个文件范围里可用的命名空间。其一般形式如下:

    namespace
    {
        //声明
    }

    我们可以使用这种没有名称的命名空间创建只有在声明他的文件中才可见的标识符。也即是说,只有在声明这个命名空间的文件中,它的成员才是可见的,它的成员才是可以被直接使用的,不需要命名空间名称来修饰。对于其他文件,该命名空间是不可见的。我们在前面曾经提到过,把全局名称的作用域限制在声明他的文件的一种方式就是把它声明为静态的。尽管C++是支持静态全局声明的,但是更好的方式就是使用这里的未命名的命名空间。

    std命名空间

      标准C++把自己的整个库定义在std命名空间中。这就是本书的大部分程序都有下面代码的原因:

      using namespace std;

      这样写是为了把std命名空间的成员都引入到当前的命名空间中,以便我们可以直接使用其中的函数和类,而不用每次都写上std::。当然,我们是可以显示地在每次使用其中成员的时候都指定std::,只要我们喜欢。例如,我们可以显示地采用如下语句指定cout:

      std::cout << “显示使用std::来指定cout”;

      如果我们的程序中只是少量地使用了std命名空间中的成员,或者是引入std命名空间可能导致命名空间的冲突的话,我们就没有必要使用using namespace std;了。然而,如果在程序中我们要多次使用std命名空间的成员,则采用using namespace std;的方式把std命名空间的成员都引入到当前命名空间中会显得方便很多,而不用每次都单独在使用的时候显示指定

    更多相关内容
  • 命名空间在多个面对对象的语言中有应用,例如JAVA,C ,C#。本文主要记录了在C#中如何调用不同命名空间的public class。 如果说类是对属性和方法的封装,那么命名空间就是对各个类的进一步封装。在同一命名空间中,...
  • C++命名空间实例解析

    2020-12-31 13:57:40
    命名空间是C++非常重要的概念,...1、每个命名空间都是个作用域 和其他作用域类似,在命名空间中的每个名字必须表示唯一实体,而在不同命名空间中,可以有相同名字的成员。 2、命名空间可以是不连续的 命名空间可以定
  • C++ 命名空间

    2021-01-03 01:46:52
    C++ 命名空间 假设这样种情况,当个班上有两个名叫 Zara 的学生时,为了明确区分它们,我们在使用名字之外,不得不使用一些额外的信息,...本质上,命名空间就是定义了个范围。 我们举个计算机系统中的例子,
  •  个命令空间个作用域,在不同名字空间命名相同的符号代表不同的实体。  通常,利用定义名字空间的办法,可以使模块划分更加方便,减少模块间的相互影响。  1、名字空间的成员  定义在名字空间中的...
  • php5.3 之后引入了命名空间的特性,从本质上讲,命名空间就是个容器,你可以将类、函数和变量放在其中,在命名空间中,你可以无条件地访问这些项,在命名空间之外,必须导入或引用命名空间,才能访问它所包含的项...
  • 主要介绍了C#命名空间与java包的区别,较为详细的分析了C#命名空间与java包的相同点与不同点,非常具有实用价值,需要的朋友可以参考下
  • C++ 如何快速获取个变量是哪个命名空间里面的? 过程是一样的。 /// @file main.cc /// @author zhaolu /// @version 1.0 /// @data 2020-03-14 #include #include #include namespace zhaolu { template class ...
  • ROS命名空间,在我的理解就是我们在个范围下(这个范围就是指的是命名空间)建立变量,节点等。这些变量,节点的有效范围就是他所在的命名空间。一般默认的是全局空间,即变量,节点全局有效。就像c++中的name ...
  • 命名空间:提供了种从名称到对象的映射;主要是通过字典来实现的。 在python中,函数、模块等都有自己的命名空间: 局部命名空间(local namespace):即函数中定义的名称 —— 包括函数中的变量、参数、局部变量...
  • PHP 命名空间(namespace)是在PHP 5.3中加入的,如果你学过C#和Java,那命名空间就不算什么新事物。... PHP 命名空间可以解决以下两类问题: ...如果个文件中包含命名空间,它必须在其它所有代码之前声明
  • 命名空间个声明性区域,为其内部的标识符(类型、函数和变量等的名称)提供个范围。命名空间用于将代码组织到逻辑组中,还可用于避免名称冲突,尤其是在基本代码包括多个库时。命名空间范围内的所有标识符彼此...
  • 命名空间 列出所有命名空间 hbase> list_namespace 新建命名空间 hbase> create_namespace 'ns1' 删除命名空间 hbase> drop_namespace 'ns1' 该命名空间必须为空,否则系统不让删除。 修改命名空间 hbase> alter...
  • 近些年,微软对其分布式文件系统(Distributed File System,DFS)做了很多改良,其中的...个DFS命名空间由很多部分组成。 1 DFS根  DFS命名空间本质上是分等级的,最顶端的是DFS根。在实际运用中,可以认为根和
  • (1)又叫全局命名空间 (2)默认命名空间引用其他命名空间方法 (3)默认命名空间引用自己的方法 (4)其他命名空间引用默认命名空间中的方法::f(); 4.C++匿名命名空间 1.3.4.1、std和cout的引入 (1)std是C++标准库定义好的...

    1.默认命名空间

    1.1 默认命名空间的定义

    默认命名空间也叫全局命名空间,所有没有置于某一具体命名空间下的代码即在默认命名空间下,例如func(),main()函数。

    #include<iostream>
    
    void func(void);
    
    int main(int argc,char**argv)
    {
    	std::cout<<"this is main"<<std::endl;
    	return 0;
    }
    
    void func(void)
    {
    	std::cout<<"this is func"<<std::endl;
    }
    

    需要注意的是:

    • 1.默认命名空间也是命名空间。
    • 2.默认命名空间是全局的。
    • 3.main()函数必须置于默认命名空间下。

    1.2 默认命名空间引用其他命名空间

    默认命名空间引用其他命名空间的方法与上一篇中的使用命名空间的方法是一样的,这里不再多说了。

    1.3 默认命名空间引用自己

    这个就是类似于C语言里简单的没有命名空间的函数调用,如下面的代码中main()调用func1()

    #include<iostream>
    
    void func1(void);
    
    int main(int argc,char**argv)
    {
    	func1();
    	return 0;
    }
    
    void func1(void)
    {
    	std::cout<<"this is func1"<<std::endl;
    }
    

    1.4 其他命名空间引用默认命名空间

    其他命名空间引用默认命名空间同样使用::,但是前面命名空间的名字是空白的,例如下面的代码中命名空间ns引用默认命名空间下的func()

    #include<iostream>
    
    void func1(void);
    
    namespace ns
    {
    	void func2(void)
    	{
    		::func1();
    	}
    }
    
    int main(int argc,char**argv)
    {
    	ns::func2();
    	return 0;
    }
    
    void func1(void)
    {
    	std::cout<<"this is ::func1"<<std::endl;
    }
    

    2.匿名命名空间

    2.1 匿名命名空间的定义

    匿名命名空间和全局命名空间有些类似,他们都没有名字,但是全局命名空间不需要自己定义,而匿名命名空间需要自己去定义,方法就是namespace后面没有空间名,直接就是 {}

    namespace
    {
    	void func(void)
    	{
    		std::cout<<"来自匿名命名空间的func()."<<std::endl;
    	}
    }
    

    2.2 匿名命名空间中引用其他命名空间

    匿名命名空间引用其他命名空间的方法与上一篇中的使用命名空间的方法是一样的,这里不再多说了。

    2.3 匿名命名空间中引用自己

    直接用,无需添加命名空间名前缀,只要确保先声明后使用的顺序就没有问题。

    2.4 其他命名空间中引用匿名命名空间

    一般匿名命名空间定义于文件前面,类似于全局函数位置,之后的命名空间可以正常访问匿名命名空间中的内容,但是匿名命名空间的作用不在于此,而是在于跨文件访问的时候。因此其实对于单个文件内部,使用匿名命名空间与全局函数并无多大差别。

    2.5 匿名命名空间的意义

    • 1.匿名命名空间中的符号限于文件内部使用,不需要被外部引用。
    • 2.匿名命名空间效果类似于全局变量和函数加static,但是比C中的static使用范围广,static只能用于修饰函数名变量名,而不能用于修饰一个类型,如struct,class,而匿名命名空间则不局限于这些。
    • 3.匿名命名空间虽然是一种特殊情况,但是用法逻辑上符合整个命名空间的一般原则。
    展开全文
  • 命名空间概念:命名空间种封装事物的方法,类似于目录和文件。 命名空间解决的问题(手册上也写的很清楚,下面按照自己的理解简化了): 1:解决程序编写者自己写的类、常量、函数和php内部的或者第三方的...
  • 命名空间与作用于跟名字的绑定相关性很大,可以结合另篇介绍Python名字、对象及其绑定的文章。 1. 命名空间 1.1 什么是命名空间 Namespace命名空间,也称名字空间,是从名字到对象的映射。Python中,大部分的命名...
  • 命名空间个包含了变量名称们(键)和它们各自相应的对象们(值)的字典。 个Python表达式可以访问局部命名空间和全局命名空间里的变量。如果个局部变量和个全局变量重名,则局部变量会覆盖全局变量。 每个...
  • emmm,这块讲了2个内容,个是命名空间个是作用域。个说吧 命名空间 A namespace is a mapping from names to objects.Most namespaces are currently implemented as Python dictionaries 上边这段...
  • 1、C++中的动态内存分配 通过new关键字进行动态内存申请 C++中的动态内存申请时基于类型进行的 delete关键用于内存释放 ... // 从堆空间获取个新的Type类型的空间 // 使用和C语言一样 delete
  • 全局变量和局部变量是我们理解命名空间的开始,我们先来看段代码: x = 2 def func(): x = 3 print('func x ---> ',x) func() print('out of func x ---> ',x) 这段代码输出的结果如下: func x —> 3 ...
  • 1.命名空间,即将代码划分成不同空间,不同空间的类名相互独立,互不冲突。个php文件中可以存在多个命名空间,第命名空间前不能有任何代码。内容空间声明后的代码便属于这个命名空间,例如: <?php echo ...
  • namespace(命名空间)相当于函数、类,划分了个区域,这样子就使得在同个页面中可以require相同的类,使用相同名字的函数 : 在项目中比较少用 name.php: <?php //命名要使用复合名称 namespace me\mine; ...
  • 从广义上来说,命名空间种封装事物的方法。在很多地方都可以见到这种抽象概念。例如,在操作系统中目录用来将相关文件分组,对于目录中的文件来说,它就扮演了命名空间的角色。具体举个例子,文件 foo.txt 可以...
  • JavaScript 中的命名空间这是个小函数,它为您在 JavaScript 中声明和使用命名空间提供了个很好的、简单的语法。 除了处理命名空间之外,它不会做任何事情:例如,它不会尝试加载其他脚本或模块。 它遵循我的...
  • php命名空间学习详解

    2020-12-18 15:57:30
    1、什么是命名空间命名空间种特殊的作用域,它包含处于该作用域下的标识符,同时它本身也是种标识符。可以把命名空间与操作系统的目录对应起来。命名空间相当于个目录,命名空间里的类,函数,常量,...
  • Python命名空间详解

    2021-01-21 17:34:14
    通俗的来说,Python中所谓的命名空间可以理解为个容器。在这个容器中可以装许多标识符。不同容器中的同名的标识符是不会相互冲突的。理解python的命名空间需要掌握三条规则: 第,赋值(包括显式赋值和隐式赋值...
  • C++命名空间

    千次阅读 2021-06-16 19:15:18
    大型应用程序经常使用来自不同厂商的开发库,几乎不可避免会使用相同的名字,也就是说个库中定义的名字可能与其他库中的名字相同...命名空间是用来限定名字的解析和使用范围的,他是C++开发大型程序的工具之 ...

    大型应用程序经常使用来自不同厂商的开发库,几乎不可避免会使用相同的名字,也就是说一个库中定义的名字可能与其他库中的名字相同而产生冲突,使得程序员不能组合格子独立的开发库到一个程序中。

    命名空间是用来限定名字的解析和使用范围的,他是C++开发大型程序的工具之一

    命名空间的原理是将全局作用于划分为一个一个的命名空间,每个命名空间是一个独立的作用域,在不同命名空间内部定义的名字彼此互不影响,从而有效的避免了命名空间的污染。

    命名空间的定义形式:

    namespace 命名空间名{
             ......
    }

    命名空间可以再全局作用于或其他命名空间内部定义,单不能再函数、结构体或类内部定义,且要保证命名空间之间不会出现名字冲突。

    在命名空间作用域内,可以包含以下内容:

    1、变量、对象以及他们的初始化

    2、枚举常量

    3、函数声明以及函数定义

    4、类、结构体声明与实现

    5、模板

    6、其他命名空间

    每个命名空间是一个作用域

    定义再命名空间中的实体称为命名空间成员。命名空间中每个名字必须是该空间中的唯一实体,不同命名空间可以具有同名成员。

    namespace A{    //定义命名空间A
        int fun,j;
        int fun(){return 10;}  //错误,通一命名空间不能有相同的名字
    }
    namespace B{    //定义命名空间B
        int fun,j;  //正确,不同命名空间可以有相同的名字
    }

    在命名空间中定义的名字可以被命名空间中的其他成员直接访问,命名空间外部的代码必须指出名字定义再那个命名空间中,即作用域运算限定命名空间,形式为:

    命名空间::成员名

    例如:

    namespace A{
    
        int i=10;
        void output1(){count<<i;}//同一个命名空间直接引用成员i
    }
    void output2(){count<<A::i;} //引用命名空间限定成员A::i

    命名空间可以是不连续的

    命名空间可以再几个部分中分开定义,即命名空间是累积的。一个命名空间可以分散在多个文件中。

    namespace A{
    
         int i;
    
    }
    
    namespace B{
    
         int i,j;
    
    }
    
    namespace  A{
    
         int j;
    
    }

    接口和实现分离

    命名空间可以不连续意味着可以做以下事情:

    1、命名空间成员如果是类,可以将作为类接口的函数声明和对象声明放在头文件中,使用这些命名空间成员的文件可以包含这些头文件。

    2、命名空间类成员的定义可以放在单独的源文件中。

    定义命名空间成员

    在命名空间内部定义的函数可以使用同一命名空间中定义的名字。

    namespace A{
         complex sub (complex& c1,complex& c2);
    }

    也可以在命名空间外部定义命名空间成员:

    A::complex A::sub(somplex& c1,complex& c2);
    {complex c;
    
     c.setdata(c1.getr()+c2.getr(),c1.geti()+c2.geti());
    
     return c;
    }

    全局命名空间

    定义在全局作用域的名字(任何类、函数或命名空间外部声明的名字)是定义在全局命名空间中的。全局命名空间存在于每个程序中,是隐式的。

    可以用作用域运算符引用全局命名空间的成员:

    int i=10;    //全局作用域
    namespace A{  //使用命名空间
    void output(){cout<<::i;}  //使用全局作用域
    }

    嵌套命名空间

    嵌套命名空间中的名字遵循名字规则:外围命名空间中的声明的名字被嵌套命名空间中同一名字的声明所屏蔽。

    namespace outer{
        int i;
        namespace inner{
            void f(){i++;}
            int i;
            void g(){i++;}
            void h(){outer::i++;}
        }
    
    }

    未命名的命名空间

    定义命名空间时如果没有给出命名空间名字,称为未命名的命名空间,定义形式为:

    namespace{
        ......
    }
    1. 未命名空间的中定义的名字可以直接使用,没有命名空间名字来限定他们
    2. 未命名空间可以再给定文件中不连续,但不能跨越文件,每个文件有自己的未命名的空间。本质上在一个文件中所有未命名空间会被系统用同一个表示代替,且区别于其他文件标识。

    未命名空间的命名空间专门用于声明局部于文件的实体。

    未命名的命名空间中定义的名字只在包含该命名空间的文件中可见。如果另一文件包含一个未命名的命名空间,俩个命名空间不相关,可以定义相同名字的实体。

    命名空间成员的使用:

    引用命名空间成员的形式为:

    命名空间::成员名

    例如:

    nspath::=10;
    nspath::nsdir::i=10;//嵌套命名空间的使用

    命名空间的别名

    可以为命名空间起一个别名来代替较长的命名空间名,形式为:

    namespace 命名空间别名 = 命名空间名;

    namespace ns_with_very_long_name{......}
    namespace NWVLN=ns_with_very_long_name;
    namespace NSPD=nspath::nsdor;

    1、using声明

    可以使用using声明引入命名空间成员,形式为:

    using 命名空间名:: 命名空间成员名;

    一个using声明一次引入一个命名空间成员,它使得无论程序使用那些名字,都非常明确。例如:

    using std ::count;//引入标准命名空间std的cout

    2、using指示

    using指示的形式为:

    using namespace 命名空间名;

    using指示使得特定命名空间的所有名字可见,没有限制。

    namespace A{
         int i,j;
    }
    void f()  //函数f再全局作用域的定义
    {   using namespace A;  //插入命名空间A的作用域
        cout<<i*j<<endl;  //直接使用命名空间A中i和j
        
    }

    类和命名空间

    对命名空间内部使用的名字的查找遵循常规的C++规则:

    namespace A{
        int i;
        namespace B{
            int i,j;
            int fi(){
                int j;
                return i;
        }
        }
        int f2(){return j;}  //错误,j未被定义
        int j=i;
    
    
    }

    在类作用域查找名字的时候,首先在成员本身中查找,然后在类中查找,然后检查外围作用域。当类包含在命名空间中的时候,发生相同的查找;首先在成员中查找,然后在类中找,再在外围命名空间中找;

    (1)实参相关的查找与类类型形参

    有简单程序:

    std::string s;

    getline(std::cin,s);调用 std::getline

    接受类类型形参的函数,以及与类本身定义在同一命名空间的函数,在用类类型对象作为实参的时候是可见的。

    当编译器再变异getline(std::cin,s);的时候,他在当前的作用域以及定义cin和string的类型的命名空间中查找匹配的函数,进而再std命名空间找到有string类型定义getline函数,所以条用getline函数不用std::限定。

    (2)标准命名空间的使用

    标准库的所有名字都是在一个名为std的标准命名空间中定义的,我们之前几乎所有的实例代码使用的都是std 的using指示:

    using namespace std;//加入标准库命名空间std到程序作用域中

    这样做程序可以不必对每个std成员(如cin,cout,endl)--处理。但是也导致程序和其他库出现冲突的机会多了起来。

    使用std限定的一个好处就是对每个std成员做限定,例如:

    std::cout<<"hello,world"<<std::endl;

    这样做虽然不方便,但是最大程度的避免了与标准命名空间名字的冲突。

    也可以用如下方法:

    using std :: cin;
    using std :: cout;
    using std::endl;

     

     

     

     

     

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 859,701
精华内容 343,880
关键字:

命名空间的一