ex24.cpp

C／C＋＋程序设计教程

        //第24章     名称空间和嵌套类

//[例24.1]名称空间是一个独立的全局命名区域
	#include<stdio.h>	
    namespace NName                     
    {  struct CType  { long  f(); long m_l;};//声明一个结构类型,名称为CType 
		 typedef long type;                  //声明一个long的别名type  
		 type funct(CType&);               //全局函数原型说明    
		 long  CType::f() {  return m_l;}     //成员函数的体内定义    
		 CType*  pobj;                    //定义一个全局对象指针 
		 type v;                           //定义一个long型的全局变量v
		 CType  obj;                      //定义一个全局对象obj
   }                                      
	NName::type NName::funct(CType& r)     //全局函数的体外定义
	{    r.m_l=10;
		type  n=r.m_l+10;		
		return n;
	}   
	void main(void)
	{	NName::pobj=&NName::obj;        
		NName::v=NName::funct(NName::obj);
		printf("NName::v=%d,obj.m_l=%d\n",NName::v,NName::pobj->f());
	}     //输出结果： NName::v=20,obj.m_l=10
//[例24.2]using声明语句简化索引名称的方式
	#include<iostream>	
    namespace NName                     
    {   struct CType  { long  f(); long m_l;}; 
		 typedef long type;                    
		 type funct(CType&r)               //全局函数在名称空间体内定义
         {  r.m_l=10;	return r.m_l+10; }                     
		 CType*  pobj; 
		 type v;
		 CType  obj;
   }     
    long  NName::CType::f() {  return m_l;}   //成员函数在名称空间的体外定义
	using namespace NName;  
	using namespace std;
	void main(void)
	{	pobj=&obj;        
		v=funct(obj);
		cout<<"v="<<v<<",obj.m_l="<<pobj->f()<<endl;
	}     //输出结果： v=20,obj.m_l=10
//[例24.3]将说明语句放置在头文件的名称空间布局
	#include<iostream>	
    #include"x.h"
	using  B::obj;
	void main(void)
	{  	B::pobj=&obj;  
	    using  B::funct;  
		B::v=funct(obj);
		 using namespace std;
		cout<<"v="<<B::v<<",obj.m_l="<<B::pobj->f()<<endl;
	}   //输出结果： v=20,obj.m_l=10
	namespace B                     
    {	long funct(A&r){  r.m_l=10;	return r.m_l+10; }  
		long  A::f()   {  return m_l;}   	
		 A*  pobj; 
		 long v;
		 A  obj;
   }
//    在头文件x.h建立的名称空间
    namespace B                     
    {   union A  { long  f(); long m_l;}; 
		 long funct(A&r); 
		 extern 	 A*  pobj; 
		 extern  long  v;
		 extern  A  obj;
	}

namespace X   {  long m=1;	}   //相当于定义全局变量long X::m=1;
	using  namespace X;
    namespace Y 
	{	long n=m+1;          //相当于long Y::n= X::m+1;
	    long k=X::d;          //error  'd' : is not a member of 'X',undeclared identifier
	}                       // X::d此时尚不存在
    namespace X   {  long d=3;	}   //定义另外一个全局变量long X::d=3;
	void f(void)	  {  d=4;		}      //此时可以有效的索引全局变量X::d
//[例24.4]名称空间的隐约索引不应构成歧义
    #include<stdio.h>	
    namespace C 
	{ 	long f( int n)    {  printf("C::f(int);");     return n;     }
		long f( double n) {  printf("C::f(double);");  return (long)n;}
	}  
	namespace D 
	{ 	long f( int n)     {  printf("D::f(int);");   return n; }
		long f( char n)   {  printf("D::f(char);");  return n; }
	}  
	void main()
	{	using C::f;     //导出一对重载函数C::f(double), C::f(int)
		using D::f;     //导出一对重载函数D::f(char),   D::f(int)
	    printf("C::f=%d,D::f=%d--",f('a'+1.0),f('a'));
		printf("C::f=%d,D::f=%d\n",C::f(98),D::f(97));
	}///输出:D::f(char);C::f(double);C::f=98,D::f=97--D::f(int);C::f(int);C::f=98,D::f=97
//[例24.5]嵌套名称空间的访问
	    namespace  OutName                          //namespace 外层名称空间名
    {   struct  SA { float x;};                     //{    外层类型声明语句；
       long   funct(long x);                         //   外层函数原型说明语句；
       SA      s[]={1,2};                            // 外层变量定义语句；
       namespace  InName                           // namespace  内层名称空间名
       {                                           // {
        double x=s[0].x;                            //    内层变量定义语句；
        float  fv(void) { return s[1].x; }          //         内层函数定义
       }                                            // }
       long   funct(long x){return InName::fv()+x;}        //外层的函数定义
    }                                             }

    #include<stdio.h>	
	void main()
	{	using OutName::InName::fv;
	    printf("OutName::InName::x=%f,f()=%f\n",OutName::InName::x,fv());
		using namespace OutName;
        printf("OutName::s[]={%f,%f}\n",s[0].x,s[1].x);
	}
    //[例24.6]名称空间的别名简化代码的书写量
    namespace  OutName                  
	{  struct  SA { float x;} s[]={1,2}; 
		namespace  InName
		{	double x=s[0].x;                             
		    float  fv(void) { return s[1].x; }                      
		}      
	}      
    #include<stdio.h>	                                 
 	void main()
	{   namespace  InN=OutName::InName;
	    printf("InN::x=%f,f()=%f\t",InN::x,InN::fv());
	    namespace Out=OutName;
		printf("Out::s[]={%f,%f}\n",Out::s[0].x,Out::s[1].x);
	}
   //[例24.7] 无名的名称空间的内部屏蔽作用
   // a.cpp文件如下
	namespace 
	{	class CType                          
		{ 	public:	 static  int num;                
		                   int m_n;
		};
		int a_n=1;
		int f(){  return CType::num; }
		int CType::num=2;
		CType obj={3};
	}
	int ga(){ return  a_n+f()+obj.m_n;}
    b.cpp文件如下:
	namespace 
	{	class CType   { 	public:	 static  int num;   int m_n;};
		int b_n=10;
		int f(){  return CType::num; }
		int CType::num=20;
		CType obj={30};
	  	int fb(){return b_n+f()+obj.m_n;}
	}
	 int gb(){return b_n+f()+obj.m_n;}
    //c.cpp文件中的代码如下:
	#include<stdio.h>	
	extern int gb();  	extern int ga();  	extern int fb();
	void main()
	{	printf("a.cpp=>%d,b.cpp=>%d\n",ga(),gb());
        //printf("b.cpp=>%d\n",fb());
	    // Linking...c.obj : error LNK2001: 
        //unresolved external symbol "int __cdecl fb(void)"   		(?fb@@YAHXZ)
	}   //程序输出结果为: a.cpp=>6,b.cpp=>60
//[例24.8] 嵌套类和外围类
	#include<stdio.h>
	class COuter  
	{	public: int m_b;	float any;
		  COuter(int n=1) {m_b=n;printf("%d.COuter::COuter()this=%p\t",m_b,this);}
		 ~COuter (){printf("COuter::~COuter()sizeof(COuter)=%d\n",sizeof(COuter));}
			 int Show();
		private:
		friend void fnest();                  //友元函数fnest的引入旨在破除私有的界限
		class CNested                      //嵌套类具有私有访问控制属性
		{  public:                         //嵌套类本身的成员是公共的
    		int m_c;  
		  CNested(int n=2)                  //构造函数和析构函数内联定义
			{m_c=n;printf("%d.CNested::CNested() this=%p\t",m_c,this);}
		 ~CNested()
	      {printf("CNested::~CNested()sizeof(CNested)=%d\n",sizeof(CNested));}	
	     int Show();	                      //声明一个嵌套类成员函数
		};
		public:
	    static	COuter  Outer(int k);       //返回外围类对象的静态成员函数Outer
	    static	CNested Nested(int k);       //返回嵌套类对象的静态成员函数Nested
	};
    int COuter::Show()
	{     printf("COuter::Show() this= %p\n",this);
          return 1;
    }
	int COuter::CNested::Show()              //嵌套类成员函数的全局范围定义
	{  ////COuter::Show();////error 'COuter::Show' : illegal call of non-static member function
		printf("CNested::Show()this=%p\n",this);
		return 0;
	}
	COuter COuter::Outer(int k) {return COuter(k);}//静态成员函数的定义	
	COuter::CNested COuter::Nested(int k)     //静态成员函数COuter::Nested的定义
	{	                                 //返回嵌套类的COuter::CNested对象
        return CNested(k);	                 //显式调用嵌套类的构造函数
	}
	void fnest()                            //外围类的全局友元函数 
	{                                    //定义COuter::CNested 嵌套类对象nested 
	 COuter::CNested nested(COuter::Nested(2)); // nested用函数COuter::Nested初始化
	 nested.Show();
	}
	void main()                     //定义外围类的对象outer
	{ COuter  outer=COuter::Outer(1);  //outer用静态成员函数COuter::Outer初始化 
	 outer.Show();              	 fnest();
	}
//[例24.9] 友元函数和嵌套类
	#include<stdio.h>
    struct CTop
    {    int m_c;
		CTop(int n){m_c=n;printf("CTop::CTop()this=%p\n",this);}
		int  Show(){printf("%d.CTop::Show() this=%p\n",m_c,this);return 0;}
    };
   class COuter  
   {    public:	COuter (int n=1){m_b=n;}
		class CNested:public CTop 
		{	 public:	 
			CNested(int n=2):CTop(n)
				{printf("CNested::CNested() this=%p\n",this);}			 		
			 int Show(COuter& r);	 
		};
		friend int CNested::Show(COuter& r);
		protected:  int m_b;
    };
   	int COuter::CNested::Show(COuter& r)
	{	CTop::Show();
		printf("CNested::Show(COuter& r=%d,&r=%p)\n",r.m_b,&r);
		return 0;
	}
     void main()
	 {	 COuter::CNested nested(10);
		 COuter outer(20);			 
		 nested.Show(outer);		
	 }