C++ 嵌套类 （详解 一站式教学）

目次

嵌套类
嵌套类的界说
嵌套类结构的访问权限
pimpl模式（了解）

---

嵌套类

嵌套类的界说

起首介绍两个概念：

• 类作用域（Class Scope）
  

类作用域是指在类界说内部的范围。在这个作用域内界说的成员（包括变量、函数、范例别名等）可以被该类的全部成员函数访问。类作用域开始于类界说的左花括号，结束于类界说的右花括号。在类作用域内，成员可以相互访问，无论它们在类界说中的声明次序怎样。

• 类名作用域（Class Name Scope）
  

类名作用域指的是可以通过类名访问的作用域。这紧张用于访问类的静态成员、嵌套范例。类名必须用于访问静态成员或嵌套范例，除非在类的成员函数内部，由于它们不依赖于类的任何特定对象。以静态成员为例：

1. class MyClass
2. {
3. public:
4.     void func(){
5.         _b = 100;//类的成员函数内访问_b
6.     }
7.     static int _a;
8.     int _b;
9. };
10. //静态成员要定义在类外，因为静态成员是一个类所共有的，如果声明在类中，每创建一个类对象就会生成一个静态数据成员
11. int MyClass::_a = 0;
13. void test0(){
14.     //这里静态数据成员为公有所以可以在类外通过类名直接访问
15.     MyClass::_a = 200;//类外部访问_a
16. }

复制代码

在函数和其他类界说的外部界说的类称为全局类，绝大多数的 C++ 类都是全局类。我们在前面界说的全部类都在全局作用域中，全局类具有全局作用域。
与之对应的，一个类A还可以界说在另一类B的界说中，这就是嵌套类结构。A类被称为B类的内部类，B类被称为A类的外部类。
以Point类和Line类为例

1. class Line
2. {
3. public:
4.     class Point{
5.     public:
6.         Point(int x,int y)
7.         : _ix(x)
8.         , _iy(y)
9.         {}
10.     private:
11.         int _ix;
12.         int _iy;
13.     };
14. public:
15.     Line(int x1, int y1, int x2, int y2)
16.     : _pt1(x1,y1)
17.     , _pt2(x2,y2)
18.     {}
19. private:
20.     Point _pt1;
21.     Point _pt2;
22. };

复制代码

Point类是界说在Line类中的内部类，无法直接创建Point对象，必要在Line类名作用域中才气创建，由于point类在line类中，只能先找到line类在访问point类

1. Point pt(1,2);//error
2. Line::Point pt2(3,4);//ok

复制代码

  Point类是Line类的内部类，并不代表Point类的数据成员会占据Line类对象的内存空间，在存储关系上并不是嵌套的结构。
  只有当Line类有Point类范例的对象成员时，Line类对象的内存结构中才会包含Point类对象（成员子对象）。
  

  （1）如果Line类中没有Point类的对象成员，sizeof(Line) = 8;
  （2）如果Line类中有两个Point类的对象成员，sizeof(Line) = 24;
  
  

   思索，如果想要利用输出流运算符输出Line对象，应该怎么实现？（紧张）
  

  最直观的实现方式是界说一个运算符重载函数，但在函数体中必要让输出流运算符处置处罚Point范例对象，以是还必要为Point类准备一个输出流运算符重载函数。
  
  

  —— 如果Point界说在Line的私有地区
  那么还必要将operator<<函数声明为Line的友元函数
  
下面为测试代码，可自行测试

1. #include <iostream>
2. using namespace std;
3. class Line
4. {
5. public:
6.     class Point {
7.     public:
8.         Point(int x, int y)
9.             : _ix(x)
10.             , _iy(y)
11.         {}
12.         friend ostream& operator<<(ostream& os, const Line::Point& rhs);
13.     private:
14.         int _ix;
15.         int _iy;
16.     };
17. public:
18.     Line(int x1, int y1, int x2, int y2)
19.         : _pt1(x1, y1)
20.         , _pt2(x2, y2)
21.     {}
22.     ~Line() {
23.         //cout << "~Line（）" << endl;
24.     }
25.     friend ostream& operator<<(ostream& os, const Line& rhs);
26.     friend ostream& operator<<(ostream& os, const Point& rhs);
27.    
28. private:
29.     Point _pt1;
30.     Point _pt2;
31. };
33. //这里会访问line的私有成员point所以在line类中声明为友元,因为又要访问point对象的数据成员，
34. //所以又要将这个函数声明为内部类的友元
35. ostream& operator<<(ostream& os, const Line::Point& rhs)
36. {
37.     os << "(" << rhs._ix << "," << rhs._iy << ")";
38.     return os;
39. }
41. //因为是输出运算符重载，不会对操作数进行修改，倾向于声明为有友元类
42. ostream& operator<<(ostream & os, const Line & rhs)
43. {
44.     os << rhs._pt1 << "------->" << rhs._pt2;
45.     return os;
46. }
47. void test()
48. {
49.     Line ll(1, 2, 3, 4);
50.     cout << ll << endl;
51. }
52. int main()
53. {
54.     test();
55.     return 0;
56. }

复制代码

嵌套类结构的访问权限

外部类对内部类的成员举行访问
内部类对外部类的成员举行访问

内部类相称于是界说在外部类中的外部类的友元类
类A界说在类B中，那么类A访问类B的成员时，就相称于默认的是类B的友元类。

下面为测试代码，可以自行测试

1. #include <iostream>
2. using namespace std;
3. class Line
4. {
5. public:
6.     class Point {
7.     public:
8.         Point(int x, int y)
9.             : _ix(x)
10.             , _iy(y)
11.         {}
12.         friend ostream& operator<<(ostream& os, const Line::Point& rhs);
13.         void print()
14.         {
15.             cout << "print" << endl;
16.         }
17.         friend class Line;
18.         void getline(const Line& rhs)
19.         {
20.             //在内部类中不需要友元声明，可以直接通过line对象直接访问成员
21.             rhs._pt1;
22.             rhs._pt2;
23.             //通过类名作用域直接访问line的私有静态成员
24.             Line::_pt3;
25.             //直接用成员名访问line的私有静态数据成员
26.             _pt3;
27.         }
28.     private:
29.         int _ix;
30.         int _iy;
31.         static int _iz;
32.     };
33. public:
34.     Line(int x1, int y1, int x2, int y2)
35.         : _pt1(x1, y1)
36.         , _pt2(x2, y2)
37.     {}
38.     ~Line() {
39.         //cout << "~Line（）" << endl;
40.     }
41.     friend ostream& operator<<(ostream& os, const Line& rhs);
42.     friend ostream& operator<<(ostream& os, const Point& rhs);
43.     void getpoint()
44.     {
45.         //在外部类中通过内部类访问内部类的公有成员
46.         _pt1.print();//ok
47.         //外部类属于内部类的类定义之外，这里是在内部类的私有数据成员
48.         //在外部类中通过内部类对象访问内部类的私有成员
49.         //_pt1._ix;//需要声明友元
50.         Point::_iz;//因为为私有，所以需要友元声明
51.         
52.         //_ix;不可能实现
53.         //_iy;同上
54.     }
55. private:
56.     Point _pt1;
57.     Point _pt2;
58.     static double _pt3;
59. };
60. //要在外部类的外面对内部类的静态成员进行定义
61. int Line::Point::_iz = 10;
62. double Line::_pt3 = 100;
63. //这里会访问line的私有成员point所以在line类中声明为友元,因为又要访问point对象的数据成员，
64. //所以又要将这个函数声明为内部类的友元
65. ostream& operator<<(ostream& os, const Line::Point& rhs)
66. {
67.     os << "(" << rhs._ix << "," << rhs._iy << ")";
68.     return os;
69. }
71. //因为是输出运算符重载，不会对操作数进行修改，倾向于声明为有友元类
72. ostream& operator<<(ostream & os, const Line & rhs)
73. {
74.     os << rhs._pt1 << "------->" << rhs._pt2;
75.     return os;
76. }
77. void test()
78. {
79.     Line ll(1, 2, 3, 4);
80.     cout << ll << endl;
81. }
82. int main()
83. {
84.     test();
85.     return 0;
86. }

复制代码

pimpl模式（了解）

现实项目标需求：盼望Line的实现全部隐藏，在源文件中实现，再将其打包成库文件，交给第三方利用。
（1）头文件只给出接口：

1. //Line.hpp
2. class Line{
3. public:
4.     Line(int x1, int y1, int x2, int y2);
5.     ~Line();
6.     void printLine() const;//打印Line对象的信息
7. private:
8.     class LineImpl;//类的前向声明
9.     LineImpl * _pimpl;
10. };

复制代码

（2）在实现文件中举行详细实现，利用嵌套类的结构（LineImpl是Line的内部类，Point是LineImpl的内部类），Line类对外公布的接口都是利用LineImpl举行详细实现的
在测试文件中创建Line对象（最外层），利用Line对外提供的接口，但是不知道详细的实现

1. //LineImpl.cc
2. class Line::LineImpl
3. {
4.     class Point{
5.     public:
6.         Point(int x,int y)
7.             : _ix(x)
8.               , _iy(y)
9.         {}
10.                 //...
11.     private:
12.         int _ix;
13.         int _iy;
14.     };
15.     //...
16. };
18. //Line.cc
19. void test0(){
20.     Line line(10,20,30,40);
21.     line.printLine();
22. }

复制代码

（3）打包库文件，将库文件和头文件交给第三方

1. sudo apt install build-essential
2. g++ -c LineImpl.cc
3. ar rcs libLine.a LineImpl.o
5. 生成libLine.a库文件
6. 编译：g++ Line.cc(测试文件) -L(加上库文件地址) -lLine(就是库文件名中的lib缩写为l，不带后缀)
7. 此时的编译指令为 g++ Line.cc -L. -lLine

复制代码

内存结构

pimpl模式是一种镌汰代码依赖和编译时间的C++编程本事，其根本头脑是将一个外部可见类的实现细节（一样平常是通过私有的非虚成员）放在一个单独的实现类中，在可见类中通过一个私有指针来间接访问该范例。
长处：

• 实现信息隐藏；
  
• 只要头文件中的接口稳定，实现文件可以随意修改，修改完毕只必要将新天生的库文件交给第三方即可；
  
• 可以实现库的平滑升级。
  

下面为测试代码，可自行测试

1. //LineImpl.cc
3. #include <iostream>
4. #include "Line.hpp"
5. using namespace std;
6. // 这是一个实现文件，不用包含测试，只需要实现头文件中的函数等内容
7. //先对成员类型进行实现
8. class Line::LineImpl
9. {
10. public:
11.     class Point{
12.     public:
13.         Point(int x,int y)
14.         : _ix(x)
15.         , _iy(y)
16.         {}
17.         ~Point()
18.         {
19.             cout << "~Point()" << endl;
20.         }
21.         void print()
22.         {
23.             cout << "("<<_ix << ","
24.                 << _iy << ")";
25.         }
26.     private:
27.         int _ix;
28.         int _iy;
29.     };
30. public:
31.     LineImpl(int x1, int y1, int x2, int y2)
32.     : _pt1(x1,y1)
33.     , _pt2(x2,y2)
34.     {
35.         cout << "LineImpl(int *4)" << endl;
36.     }
37.     ~LineImpl()
38.     {
39.         cout << "~LineImpl()" << endl;
40.     }
41.     void printline()
42.     {
43.         _pt1.print();
44.         cout << "-----> ";
45.         _pt2.print();
46.         cout << endl;
47.     }
48. private:
49.     Point _pt1;
50.     Point _pt2;
51. };
53. Line::Line(int x1, int y1, int x2, int y2)
54.     :_pimpl(new LineImpl(x1,y1, x2,y2))
55. {
56.     cout << "Line(int * 4)" << endl;
57. }
58. Line :: ~Line()
59. {
60.     cout << "~Line()" << endl;
61.     if(_pimpl)
62.     {
63.         delete _pimpl;
64.         _pimpl = nullptr;
65.     }
66. }
67. void Line::printLine() const{
68.     _pimpl->printline();
69. }
71. // test.cc
73. #include "Line.hpp"
74. #include <iostream>
75. using std::cout;
76. using std::endl;
78. void test()
79. {
80.     Line ll(1,2,3,4);
81.     ll.printLine();
82. }
84. int main()
85. {
86.     test();
87.     return 0;
88. }
90. //Line.hpp
92. #ifndef _Line_HPP_
93. #define _Line_HPP_
95. class Line {
96. public:
97.     Line(int x1, int y1, int x2, int y2);
98.     ~Line();
99.     //提供给客户使用的功能
100.     void printLine() const;//打印Line对象的信息
101. private:
102.     class LineImpl;//类的前向声明
103.     LineImpl* _pimpl;
104. };
106. #endif

复制代码