嵌套类，PIMPL

body, table{font-family: 微软雅黑; font-size: 10pt}
table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;}
th{border: 1px solid gray; padding: 4px; background-color: #DDD;}
td{border: 1px solid gray; padding: 4px;}
tr:nth-child(2n){background-color: #f8f8f8;}

类作用域：

1、作用域可分为类作用域、类名的作用域以及对象的作用域几部分内容。

2、在类中定义的成员变量和成员函数的作用域是整个类，这些名称只有在类中（包含类的定义部分和类外函数实现部分）是可见的，在类外是不可见的，因此，可以在不同类中使用相同的成员名。另外，类作用域意味着不能从外部直接访问类的任何成员，即使该成员的访问权限是public，也要通过对象名来调用，对于static成员，要指定类名来调用。

3、如果发生“屏蔽”现象，类成员的可见域将小于作用域，但此时可借助this指针或“类名::”形式指明所访问的是类成员，这有些类似于使用“::”访问全局变量。

#include <iostream> using namespace std; int x = 100;                               //定义性声明，全局int型变量x int z = 200;                               //定义性声明，全局int型变量z class Example                            //Example类定义 {         int x;                                 //默认为private的成员列表         int y; public:         Example(int xp = 0, int yp = 0)       //构造函数         {                 x = xp;                 y = yp;         }         void print(int x)                                  //成员函数print，形参为x         {                 cout << "传递来的参数:  " <<x  << endl;                                                            //形参x覆盖掉了成员x和全局变量x                 cout << "成员x:  " << (this->x) << ", 成员y:  " << y << endl;                            //此处的y指的是成员y，如果要访问成员x，可使用this指针                 cout << "除了this指针外，还可以使用类名::的形式：" << endl;                 cout << "成员x:  " << Example::x << ", 成员y:  " << y << endl;                           //或使用类名加作用域限定符的形式指明要访问成员x                 cout << "全局x:  " << (::x) << endl;                                                                     //访问全局变量x                 cout << "全局z:  " << z << endl;                                                                         //没有形参、数据成员对全局变量z构成屏蔽，直接访问z即可         } };

int main() {         Example ex1;                                              //声明一个Example类的对象ex1         ex1.print(5);                                                //调用成员函数print()         return 0; }

类定义的作用域与可见域：

使用类名创建对象时，首要的前提是类名可见，类名是否可见取决于类定义的可见域，该可见域同样包含在其作用域中，类本身可被定义在3种作用域内，这也是类定义的作用域：

（1）全局作用域

在函数和其他类定义的外部定义的类称为全局类，全局类具有全局作用域。

（2）类作用域 ( 类中类、嵌套类 )

一个类可以定义在另一类的定义中，这是所谓嵌套类，举例来说，如果类A定义在类B中，如果A的访问权限是public，则A的作用域可认为和B的作用域相同，不同之处在于必须使用B::A的形式访问A的类名。当然，如果A的访问权限是private，则只能在类内使用类名创建该类的对象，无法在外部创建A类的对象。

（3）块作用域

类的定义在代码块中，这是所谓局部类，该类完全被块包含，其作用域仅仅限于定义所在块，不能在块外使用类名声明该类的对象。

（4）类名也存在覆盖

和普通变量的覆盖原则一样，类名也存在“屏蔽”和“覆盖”，不过，依旧可使用作用域声明符“::”指定具体使用的类名，如“::类名”访问的是全局类，使用“外部类::嵌套类”访问嵌套类。

在一个类的内部定义另一个类，我们称之为嵌套类（nested class），或者嵌套类型。之所以引入这样一个嵌套类，往往是因为外围类需要使用嵌套类对象作为底层实现，并且该嵌套类只用于外围类的实现，且同时可以对用户隐藏该底层实现。

   虽然嵌套类在外围类内部定义，但它是一个独立的类，基本上与外围类不相关。它的成员不属于外围类，同样，外围类的成员也不属于该嵌套类。嵌套类的出现只是告诉外围类有一个这样的类型成员供外围类使用。并且，外围类对嵌套类成员的访问没有任何特权，嵌套类对外围类成员的访问也同样如此，它们都遵循普通类所具有的标号访问控制。

   若不在嵌套类内部定义其成员，则其定义只能写到与外围类相同的作用域中，且要用外围类进行限定，不能把定义写在外围类中。例如，嵌套类的静态成员就是这样的一个例子。

   前面说过，之所以使用嵌套类的另一个原因是达到底层实现隐藏的目的。为了实现这种目的，我们需要在另一个头文件中定义该嵌套类，而只在外围类中前向声明这个嵌套类即可。当然，在外围类外面定义这个嵌套类时，应该使用外围类进行限定。使用时，只需要在外围类的实现文件中包含这个头文件即可。

   另外，嵌套类可以直接引用外围类的静态成员、类型名和枚举成员，即使这些是private的。

//PIMPL模式优点：  (pointer to implementation) //1. 实现信息隐藏 //2. 保持接口的稳定 --> 只要保证头文件不做修改， //   对实现文件进行修改 -->  对库进行升级 //3. 如果是第三方公司在使用该库，可以做到平滑升级 //   它能够满足二进制兼容性 //pointer to implementation, 指向实现的指针 --------nested.h-------- #ifndef __NESTED_H__ #define __NESTED_H__ #include<iostream> using namespace std; class Line {         private:                 class LinePimpl;     // 前向声明                 LinePimpl* _LinePimpl;         public:                 Line(int,int,int,int);                 ~Line();                 void printLine(); }; #endif --------main.cpp-------- #include"nested.h" #include<iostream> using namespace std; int main() {         Line l1(1,2,3,4);         l1.printLine();         return 0; }

--------nested.cpp-------- // LinePimpl 实现 #include"nested.h" #include<iostream> using namespace std; class Line::LinePimpl   // 这里的Line::可以不要，类里面只是前向声明，不存在作用域范围 {         private:                 class Point     // 嵌套类                 {                                 int _x;      // 最开头，默认private                                 int _y;                         public:                                 Point(int x=0,int y=0):_x(x),_y(y)                                 {                                         cout<<"Line::LinePimpl::Point::Point(int,int)"<<endl;                                 }                                 ~Point()                                 {                                         cout<<"Line::LinePimpl::Point::~Point()"<<endl;                                 }                                 void printPoint();                 };                 Point _p1;                 Point _p2;         public:                 LinePimpl(int ix=0,int iy=0,int jx=0,int jy=0):_p1(ix,iy),_p2(jx,jy)                 {                         cout<<"Line::LinePimpl::LinePimpl(int,int,int,int)"<<endl;                 }                 ~LinePimpl()                 {                         cout<<"Line::LinePimpl::~LinePimpl()"<<endl;                 }                 void printLine(); }; void Line::LinePimpl::Point::printPoint() {         cout<<"Line::LinePimpl::Point::printPoint()"<<endl;         cout<<"("<<_x<<","<<_y<<")"<<endl; } void Line::LinePimpl::printLine() {         cout<<"Line::LinePimpl::printLine()"<<endl;         _p1.printPoint();         cout<<"->"<<endl;         _p2.printPoint(); } //外围类Line实现 Line::Line(int x1=0,int y1=0,int x2=0,int y2=0):_LinePimpl(new LinePimpl(x1,y1,x2,y2)) {         cout<<"Line::Line(int,int,int,int)"<<endl; } Line::~Line() {         cout<<"Line::~Line()"<<endl;         delete _LinePimpl; } void Line::printLine() {         cout<<"Line::printLine()"<<endl;         _LinePimpl->printLine(); }