C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。 类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。

C++ 类定义和访问

定义一个类，本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据，但它定义了类的名称意味着什么，也就是说，它定义了类的对象包括了什么，以及可以在这个对象上执行哪些操作。
C 类 & 对象 - 图1
类定义是以关键字class开头，后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。例如，我们使用关键字class定义 Box 数据类型，如下所示：

  1. class Box
  2. {
  3.    public:
  4.       double length;   // 盒子的长度
  5.       double breadth;  // 盒子的宽度
  6.       double height;   // 盒子的高度
  7. };

关键字public确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。您也可以指定类的成员为private或protected，这个我们稍后会进行讲解。

定义 C++ 对象

类提供了对象的蓝图，所以基本上，对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。下面的语句声明了类 Box 的两个对象：

  1. Box Box1;          // 声明 Box1，类型为 Box
  2. Box Box2;          // 声明 Box2，类型为 Box

对象 Box1 和 Box2 都有它们各自的数据成员。

访问数据成员

类的对象的公共数据成员可以使用直接成员访问运算符.来访问。
image.png
为了更好地理解这些概念，让我们尝试一下下面的实例：

  1. #include <iostream>
  3. using namespace std;
  5. class Box
  6. {
  7.    public:
  8.       double length;   // 长度
  9.       double breadth;  // 宽度
  10.       double height;   // 高度
  11.       // 成员函数声明
  12.       void set( double len, double bre, double hei );
  13.       double get(void)
  14.       {
  15.          return length * breadth * height;
  16.       }
  18. };
  20. // 成员函数定义
  21. void Box::set( double len, double bre, double hei)
  22. {
  23.     length = len;
  24.     breadth = bre;
  25.     height = hei;
  26. }
  29. int main( )
  30. {
  31.    Box Box1;        // 声明 Box1，类型为 Box
  32.    Box Box2;        // 声明 Box2，类型为 Box
  33.    Box Box3;        // 声明 Box3，类型为 Box
  34.    double volume = 0.0;     // 用于存储体积
  36.    // box 1 详述
  37.    Box1.height = 5.0; 
  38.    Box1.length = 6.0; 
  39.    Box1.breadth = 7.0;
  41.    // box 2 详述
  42.    Box2.height = 10.0;
  43.    Box2.length = 12.0;
  44.    Box2.breadth = 13.0;
  46.    // box 1 的体积
  47.    volume = Box1.height * Box1.length * Box1.breadth;
  48.    cout << "Box1 的体积：" << volume <<endl;
  50.    // box 2 的体积
  51.    volume = Box2.height * Box2.length * Box2.breadth;
  52.    cout << "Box2 的体积：" << volume <<endl;
  55.    // box 3 详述
  56.    Box3.set(16.0, 8.0, 12.0); 
  57.    volume = Box3.get(); 
  58.    cout << "Box3 的体积：" << volume <<endl;
  59.    return 0;
  60. }
  62. /* 
  63. Box1 的体积：210
  64. Box2 的体积：1560
  65. Box3 的体积：1536
  66. */

需要注意的是，私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问。我们将在后续的教程中学习如何访问私有成员和受保护的成员。

类 & 对象详解

到目前为止，我们已经对 C++ 的类和对象有了基本的了解。下面的列表中还列出了其他一些 C++ 类和对象相关的概念，可以点击相应的链接进行学习。

概念 描述
类访问修饰符 类成员可以被定义为 public、private 或 protected。默认情况下是定义为 private。
类成员函数 类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。
构造函数 & 析构函数 类的构造函数是一种特殊的函数，在创建一个新的对象时调用。类的析构函数也是一种特殊的函数，在删除所创建的对象时调用。
C++ 拷贝构造函数 拷贝构造函数，是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
C++ 友元函数 友元函数 可以访问类的 private 和 protected 成员。
C++ 内联函数 通过内联函数，编译器试图在调用函数的地方扩展函数体中的代码。
C++ 中的 this 指针 每个对象都有一个特殊的指针 this ，它指向对象本身。
C++ 中指向类的指针 指向类的指针方式如同指向结构的指针。实际上，类可以看成是一个带有函数的结构。
C++ 类的静态成员 类的数据成员和函数成员都可以被声明为静态的。

类成员函数

类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。
让我们看看之前定义的类 Box，现在我们要使用成员函数来访问类的成员，而不是直接访问这些类的成员：

  1. class Box
  2. {
  3.    public:
  4.       double length;         // 长度
  5.       double breadth;        // 宽度
  6.       double height;         // 高度
  7.       double getVolume(void);// 返回体积
  8. };

成员函数可以定义在类定义内部，或者单独使用 范围解析运算符 :: 来定义。在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。所以您可以按照如下方式定义 getVolume() 函数：

  1. class Box
  2. {
  3.    public:
  4.       double length;      // 长度
  5.       double breadth;     // 宽度
  6.       double height;      // 高度
  8.       double getVolume(void)
  9.       {
  10.          return length * breadth * height;
  11.       }
  12. };

您也可以在类的外部使用范围解析运算符 :: 定义该函数，如下所示：

  1. double Box::getVolume(void)
  2. {
  3.     return length * breadth * height;
  4. }

在这里，需要强调一点，在 :: 运算符之前必须使用类名。调用成员函数是在对象上使用点运算符（.），这样它就能操作与该对象相关的数据，如下所示：

  1. Box myBox;          // 创建一个对象
  3. myBox.getVolume();  // 调用该对象的成员函数

让我们使用上面提到的概念来设置和获取类中不同的成员的值：

  1. #include <iostream>
  3. using namespace std;
  5. class Box
  6. {
  7.    public:
  8.       double length;         // 长度
  9.       double breadth;        // 宽度
  10.       double height;         // 高度
  12.       // 成员函数声明
  13.       double getVolume(void);
  14.       void setLength( double len );
  15.       void setBreadth( double bre );
  16.       void setHeight( double hei );
  17. };
  19. // 成员函数定义
  20. double Box::getVolume(void)
  21. {
  22.     return length * breadth * height;
  23. }
  25. void Box::setLength( double len )
  26. {
  27.     length = len;
  28. }
  30. void Box::setBreadth( double bre )
  31. {
  32.     breadth = bre;
  33. }
  35. void Box::setHeight( double hei )
  36. {
  37.     height = hei;
  38. }
  40. // 程序的主函数
  41. int main( )
  42. {
  43.    Box Box1;                // 声明 Box1，类型为 Box
  44.    Box Box2;                // 声明 Box2，类型为 Box
  45.    double volume = 0.0;     // 用于存储体积
  47.    // box 1 详述
  48.    Box1.setLength(6.0); 
  49.    Box1.setBreadth(7.0); 
  50.    Box1.setHeight(5.0);
  52.    // box 2 详述
  53.    Box2.setLength(12.0); 
  54.    Box2.setBreadth(13.0); 
  55.    Box2.setHeight(10.0);
  57.    // box 1 的体积
  58.    volume = Box1.getVolume();
  59.    cout << "Box1 的体积：" << volume <<endl;
  61.    // box 2 的体积
  62.    volume = Box2.getVolume();
  63.    cout << "Box2 的体积：" << volume <<endl;
  64.    return 0;
  65. }
  67. /*
  68. Box1 的体积： 210
  69. Box2 的体积： 1560
  70. */

构造函数 & 析构函数

类的构造函数是类的一种特殊的成员函数，它会在每次创建类的新对象时执行。
构造函数的名称与类的名称是完全相同的，并且不会返回任何类型，也不会返回 void。构造函数可用于为某些成员变量设置初始值。
下面的实例有助于更好地理解构造函数的概念：

  1. #include <iostream>
  3. using namespace std;
  5. class Line
  6. {
  7.    public:
  8.       Line();  // 这是构造函数
  9.       void setLength( double len );
  10.       double getLength( void );
  12.    private:
  13.       double length;
  14. };
  16. // 成员函数定义，包括构造函数
  17. Line::Line(void)
  18. {
  19.     cout << "Object is being created" << endl;
  20. }
  22. void Line::setLength( double len )
  23. {
  24.     length = len;
  25. }
  27. double Line::getLength( void )
  28. {
  29.     return length;
  30. }
  33. // 程序的主函数
  34. int main( )
  35. {
  36.    Line line;
  37.    // 设置长度
  38.    line.setLength(6.0); 
  39.    cout << "Length of line : " << line.getLength() <<endl;
  40.    return 0;
  41. }
  43. /* 
  44. Object is being created
  45. Length of line : 6 
  46. */

带参数的构造函数

默认的构造函数没有任何参数，但如果需要，构造函数也可以带有参数。这样在创建对象时就会给对象赋初始值，如下面的例子所示：

  1. #include <iostream>
  3. using namespace std;
  5. class Line
  6. {
  7.    public:
  8.       Line(double len);  // 这是构造函数
  9.       void setLength( double len );
  10.       double getLength( void );
  12.    private:
  13.       double length;
  14. };
  17. // 成员函数定义，包括构造函数
  18. Line::Line( double len)
  19. {
  20.     cout << "Object is being created, length = " << len << endl;
  21.     length = len;
  22. }
  24. void Line::setLength( double len )
  25. {
  26.     length = len;
  27. }
  29. double Line::getLength( void )
  30. {
  31.     return length;
  32. }
  35. // 程序的主函数
  36. int main( )
  37. {
  38.    Line line(10.0);
  39.    // 获取默认设置的长度
  40.    cout << "Length of line : " << line.getLength() <<endl;
  41.    // 再次设置长度
  42.    line.setLength(6.0); 
  43.    cout << "Length of line : " << line.getLength() <<endl;
  44.    return 0;
  45. }

使用初始化列表来初始化字段

使用初始化列表来初始化字段：

  1. Line::Line( double len): length(len)
  2. {
  3.     cout << "Object is being created, length = " << len << endl;
  4. }

上面的语法等同于如下语法：

  1. Line::Line( double len)
  2. {
  3.     length = len;
  4.     cout << "Object is being created, length = " << len << endl;
  5. }

假设有一个类 C，具有多个字段 X、Y、Z 等需要进行初始化，同理地，您可以使用上面的语法，只需要在不同的字段使用逗号进行分隔，如下所示：

  1. C::C( double a, double b, double c): X(a), Y(b), Z(c)
  2. {
  3.   ....
  4. }

类的析构函数

类的析构函数是类的一种特殊的成员函数，它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的，只是在前面加了个波浪号 (~)作为前缀，它不会返回任何值，也不能带有任何参数。析构函数有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。
下面的实例有助于更好地理解析构函数的概念：

  1. #include <iostream>
  3. using namespace std;
  5. class Line
  6. {
  7.    public:
  8.       Line();   // 这是构造函数声明
  9.       ~Line();  // 这是析构函数声明
  10.       void setLength( double len );
  11.       double getLength( void );
  13.    private:
  14.       double length;
  15. };
  18. // 成员函数定义，包括构造函数
  19. Line::Line(void)
  20. {
  21.     cout << "Object is being created" << endl;
  22. }
  23. Line::~Line(void)
  24. {
  25.     cout << "Object is being deleted" << endl;
  26. }
  27. void Line::setLength( double len )
  28. {
  29.     length = len;
  30. }
  32. double Line::getLength( void )
  33. {
  34.     return length;
  35. }
  38. // 程序的主函数
  39. int main( )
  40. {
  41.    Line line;
  42.    // 设置长度
  43.    line.setLength(6.0); 
  44.    cout << "Length of line : " << line.getLength() <<endl;
  45.    return 0;
  46. }
  48. /* 
  49. Object is being created
  50. Length of line : 6
  51. Object is being deleted 
  52. */

C++ 拷贝构造函数

拷贝构造函数是一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：

  • 通过使用另一个同类型的对象来初始化新创建的对象。
  • 复制对象把它作为参数传递给函数。
  • 复制对象，并从函数返回这个对象。

如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下：

  1. classname(const classname &obj){// 构造函数的主体}

在这里，obj 是一个对象引用，该对象是用于初始化另一个对象的。

  1. #include <iostream>
  3. using namespace std;
  5. class Line
  6. {
  7.    public:
  8.       Line( int len );             // 简单的构造函数
  9.       Line( const Line &obj);      // 拷贝构造函数
  10.       ~Line();                     // 析构函数
  11.       int getLength( void );
  13.    private:
  14.       int *ptr;
  15. };
  17. // 成员函数定义，包括构造函数
  18. Line::Line(int len)
  19. {
  20.     cout << "调用构造函数" << endl;
  21.     // 为指针分配内存
  22.     ptr = new int;
  23.     *ptr = len;
  24. }
  26. Line::Line(const Line &obj)
  27. {
  28.     cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
  29.     ptr = new int;
  30.     *ptr = *obj.ptr; // 拷贝值
  31. }
  33. Line::~Line(void)
  34. {
  35.     cout << "释放内存" << endl;
  36.     delete ptr;
  37. }
  38. int Line::getLength( void )
  39. {
  40.     return *ptr;
  41. }
  43. void display(Line obj)
  44. {
  45.    cout << "line 大小 : " << obj.getLength() <<endl;
  46. }
  49. // 程序的主函数
  50. int main( )
  51. {
  52.    Line line1(10);
  53.    display(line1);
  54.    return 0;
  55. }
  57. /* 
  58. 调用构造函数
  59. 调用拷贝构造函数并为指针 ptr 分配内存
  60. line 大小 : 10
  61. 释放内存
  62. 释放内存
  63. */

下面的实例对上面的实例稍作修改，通过使用已有的同类型的对象来初始化新创建的对象：

  1. #include <iostream>
  3. using namespace std;
  5. class Line
  6. {
  7.    public:
  8.       Line( int len );             // 简单的构造函数
  9.       Line( const Line &obj);      // 拷贝构造函数
  10.       ~Line();                     // 析构函数
  11.       int getLength( void );
  13.    private:
  14.       int *ptr;
  15. };
  17. // 成员函数定义，包括构造函数
  18. Line::Line(int len)
  19. {
  20.     cout << "调用构造函数" << endl;
  21.     // 为指针分配内存
  22.     ptr = new int;
  23.     *ptr = len;
  24. }
  26. Line::Line(const Line &obj)
  27. {
  28.     cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
  29.     ptr = new int;
  30.     *ptr = *obj.ptr; // 拷贝值
  31. }
  33. Line::~Line(void)
  34. {
  35.     cout << "释放内存" << endl;
  36.     delete ptr;
  37. }
  38. int Line::getLength( void )
  39. {
  40.     return *ptr;
  41. }
  43. void display(Line obj)
  44. {
  45.    cout << "line 大小 : " << obj.getLength() <<endl;
  46. }
  48. // 程序的主函数
  49. int main( )
  50. {
  51.    Line line1(10);
  52.    Line line2 = line1; // 这里也调用了拷贝构造函数
  53.    display(line1);
  54.    display(line2);
  55.    return 0;
  56. }
  58. /* 
  59. 调用构造函数
  60. 调用拷贝构造函数并为指针 ptr 分配内存
  61. 调用拷贝构造函数并为指针 ptr 分配内存
  62. line 大小 : 10
  63. 释放内存
  64. 调用拷贝构造函数并为指针 ptr 分配内存
  65. line 大小 : 10
  66. 释放内存
  67. 释放内存
  68. 释放内存 
  69. */

C++ 友元函数

类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。
友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。
如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 friend，如下所示：

  1. class Box
  2. {
  3.    double width;
  4. public:
  5.    double length;
  6.    friend void printWidth( Box box );
  7.    void setWidth( double wid );
  8. };

声明类 ClassTwo 的所有成员函数作为类 ClassOne 的友元，需要在类 ClassOne 的定义中放置如下声明：

  1. friend class ClassTwo;

因为友元函数没有this指针，则参数要有三种情况：
要访问非static成员时，需要对象做参数；
要访问static成员或全局变量时，则不需要对象做参数；
如果做参数的对象是全局对象，则不需要对象做参数.
可以直接调用友元函数，不需要通过对象或指针
实例代码：

  1. class Box
  2. {
  3.     friend void Print(const Box &obj); //声明友元函数
  4. };
  6. void Print(const Box& obj）
  7. {
  8.     //函数体
  9. }
  11. void main()
  12. {
  13.     Box obj;
  14.     Print(obj); //直接调用
  15. }

请看下面的程序：

  1. #include <iostream>
  2. using namespace std;
  4. class Box
  5. {
  6.     double width;
  7. public:
  8.     friend void printWidth(Box box);
  9.     friend class BigBox;
  10.     void setWidth(double wid);
  11.     double getWidth();
  12. };
  13. // 成员函数定义
  14. void Box::setWidth(double wid)
  15. {
  16.     width = wid;
  17. };
  18. double Box::getWidth(){
  19.   return width;
  20. };
  23. class BigBox
  24. {
  25. public :
  26.     void Print(int width, Box &box)
  27.     {
  28.         // BigBox是Box的友元类，它可以直接访问Box类的任何成员
  29.         box.setWidth(width);
  30.         cout << "Width of box : " << box.width << endl;
  31.     }
  32. };
  34. // 请注意：printWidth() 不是任何类的成员函数
  35. void printWidth(Box box)
  36. {
  37.     // 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员
  38.     cout << "Width of box : " << box.width << endl;
  39. }
  41. // 程序的主函数
  42. int main()
  43. {
  44.     Box box;
  45.     BigBox bigbox;
  46.     box.setWidth(10.0);     // 使用成员函数设置宽度
  47.     printWidth(box);        // 使用友元函数输出宽度
  48.     bigbox.Print(20, box);  // 使用友元类中的方法设置宽度
  49.     // getchar();
  50.     cout << box.getWidth() << endl;
  51.     box.setWidth(100);
  52.     cout << box.getWidth() << endl;
  53.     return 0;
  54. }
  56. /* 
  57. Width of box : 10
  58. Width of box : 20
  59. 20
  60. 100
  61. */

C++ 内联函数

C++ 内联函数是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。
对内联函数进行任何修改，都需要重新编译函数的所有客户端，因为编译器需要重新更换一次所有的代码，否则将会继续使用旧的函数。
如果想把一个函数定义为内联函数，则需要在函数名前面放置关键字 inline，在调用函数之前需要对函数进行定义。如果已定义的函数多于一行，编译器会忽略 inline 限定符。
在类定义中的定义的函数都是内联函数，即使没有使用 inline 说明符。
下面是一个实例，使用内联函数来返回两个数中的最大值：

  1. #include <iostream>
  2. using namespace std;
  4. inline int Max(int x, int y)
  5. {
  6.    return (x > y)? x : y;
  7. }
  9. int main( )
  10. {
  11.    cout << "Max (20,10): " << Max(20,10) << endl;
  12.    cout << "Max (0,200): " << Max(0,200) << endl;
  13.    cout << "Max (100,1010): " << Max(100,1010) << endl;
  14.    return 0;
  15. }
  17. /* 
  18. Max (20,10): 20
  19. Max (0,200): 200
  20. Max (100,1010): 1010 
  21. */

内联函数inline：引入内联函数的目的是为了解决程序中函数调用的效率问题，这么说吧，程序在编译器编译的时候，编译器将程序中出现的内联函数的调用表达式用内联函数的函数体进行替换，而对于其他的函数，都是在运行时候才被替代。这其实就是个空间代价换时间的节省。所以内联函数一般都是1-5行的小函数。在使用内联函数时要留神：

  • 在内联函数内不允许使用循环语句和开关语句；
  • 内联函数的定义必须出现在内联函数第一次调用之前；
  • 类结构中所在的类说明内部定义的函数是内联函数。

⚠️注意: 只有当函数只有 10 行甚至更少时才将其定义为内联函数.
定义 当函数被声明为内联函数之后, 编译器会将其内联展开, 而不是按通常的函数调用机制进行调用.
优点 当函数体比较小的时候, 内联该函数可以令目标代码更加高效. 对于存取函数以及其它函数体比较短, 性能关键的函数, 鼓励使用内联.
缺点 滥用内联将导致程序变慢. 内联可能使目标代码量或增或减, 这取决于内联函数的大小. 内联非常短小的存取函数通常会减少代码大小, 但内联一个相当大的函数将戏剧性的增加代码大小. 现代处理器由于更好的利用了指令缓存, 小巧的代码往往执行更快。
结论 一个较为合理的经验准则是, 不要内联超过 10 行的函数. 谨慎对待析构函数, 析构函数往往比其表面看起来要更长, 因为有隐含的成员和基类析构函数被调用!
另一个实用的经验准则: 内联那些包含循环或 switch 语句的函数常常是得不偿失 (除非在大多数情况下, 这些循环或 switch 语句从不被执行).
有些函数即使声明为内联的也不一定会被编译器内联, 这点很重要; 比如虚函数和递归函数就不会被正常内联. 通常, 递归函数不应该声明成内联函数.(递归调用堆栈的展开并不像循环那么简单, 比如递归层数在编译时可能是未知的, 大多数编译器都不支持内联递归函数). 虚函数内联的主要原因则是想把它的函数体放在类定义内, 为了图个方便, 抑或是当作文档描述其行为, 比如精短的存取函数

C++ 中的 this 指针

在 C++ 中，每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。
友元函数没有 this 指针，因为友元不是类的成员。只有成员函数才有 this 指针。
下面的实例有助于更好地理解 this 指针的概念：

  1. #include <iostream>
  3. using namespace std;
  5. class Box
  6. {
  7.    public:
  8.       // 构造函数定义
  9.       Box(double l=2.0, double b=2.0, double h=2.0)
  10.       {
  11.          cout <<"Constructor called." << endl;
  12.          length = l;
  13.          breadth = b;
  14.          height = h;
  15.       }
  16.       double Volume()
  17.       {
  18.          return length * breadth * height;
  19.       }
  20.       int compare(Box box)
  21.       {
  22.          return this->Volume() > box.Volume();
  23.       }
  24.    private:
  25.       double length;     // Length of a box
  26.       double breadth;    // Breadth of a box
  27.       double height;     // Height of a box
  28. };
  30. int main(void)
  31. {
  32.    Box Box1(1.0, 2.0, 3.0);    // Declare box1
  33.    Box Box2(4.0, 5.0, 6.0);    // Declare box2
  34.    Box *Box1Ptr =  &Box1;
  35.    Box *Box2Ptr =  &Box2;
  37.    if(Box1.compare(Box2))
  38.    {
  39.       cout << "Box2 is smaller than Box1" <<endl;
  40.    }
  41.    else
  42.    {
  43.       cout << "Box2 is equal to or larger than Box1" <<endl;
  44.    }
  45.   cout << Box1Ptr->Volume() << endl;
  46.   cout << Box2Ptr->Volume() << endl;
  47.   printf("%f\n",Box1Ptr->Volume());
  48.   printf("%f\n",Box2Ptr->Volume());
  49.   return 0;
  50. }
  52. /* 
  53. Constructor called.
  54. Constructor called.
  55. Box2 is equal to or larger than Box1
  56. 6
  57. 120
  58. 6.000000
  59. 120.000000
  60. */

引入 this：当我们调用成员函数时，实际上是替某个对象调用它。
成员函数通过一个名为 this 的额外隐式参数来访问调用它的那个对象，当我们调用一个成员函数时，用请求该函数的对象地址初始化 this。例如:
如果调用 box.compare()则编译器负责把 box 的地址传递给 compare 的隐式形参 this，可以等价地认为编译器将该调用重写成了以下形式：

  1. //伪代码，用于说明调用成员函数的实际执行过程
  2. Box::compare(&box,Box box)

其中，调用 compare 的 compare 成员时传入了 box 的地址。
在成员函数内部，我们可以直接使用调用该函数的对象的成员，而无须通过成员访问运算符来做到这一点，因为 this 所指的正是这个对象。任何对类成员的直接访问都被看作是对 this 的隐式引用，也就是说，当 compare 使用 Volume 时，它隐式地使用 this 指向的成员，就像我们书写了 this->Volume() 一样。
对于我们来说，this 形参是隐式定义的。实际上，任何自定义名为 this 的参数或变量的行为都是非法的。我们可以在成员函数体内部使用 this，因此尽管没有必要，我们还是能把 isbn 定义成如下形式：

  1. std::int compare() const { return this->Volume(); }

因为 this 的目的总是指向“这个”对象，所以 this 是一个常量指针（参见2.4.2节，第56页），我们不允许改变 this 中保存的地址。

  1. #include <iostream>
  2. using namespace std;
  4. class Box{
  5.     public:
  6.         Box(){;}
  7.         ~Box(){;}
  8.         Box* get_address()   //得到this的地址
  9.         {
  10.             return this;
  11.         }
  12. };
  14. int main(){
  16.     Box box1;
  17.     Box box2;
  19.     // Box* 定义指针p接受对象box的get_address()成员函数的返回值，并打印
  20.     Box* p = box1.get_address();  
  21.     cout << p << endl;
  23.     p = box2.get_address();
  24.     cout << p << endl; 
  26.     return 0;
  27. }
  29. /* 
  30. 0x7ffee6bda788
  31. 0x7ffee6bda780 
  32. */

⚠️注意：this 指针的类型可理解为 Box*

C++ 中指向类的指针

一个指向 C++ 类的指针与指向结构的指针类似，访问指向类的指针的成员，需要使用成员访问运算符 ->，就像访问指向结构的指针一样。与所有的指针一样，您必须在使用指针之前，对指针进行初始化。
下面的实例有助于更好地理解指向类的指针的概念：

  1. #include <iostream>
  2. using namespace std;
  4. class Box
  5. {
  6.    public:
  7.       Box(double l=2.0, double b=2.0, double h=2.0)  // 构造函数定义
  8.       { 
  9.          cout <<"Constructor called." << endl;
  10.          length = l;
  11.          breadth = b;
  12.          height = h;
  13.       }
  14.       double Volume()
  15.       {
  16.          return length * breadth * height;
  17.       }
  18.    private:
  19.       double length;     // Length of a box
  20.       double breadth;    // Breadth of a box
  21.       double height;     // Height of a box
  22. };
  24. int main(void)
  25. {
  26.    Box Box1(3.3, 1.2, 1.5);    // Declare box1
  27.    Box Box2(8.5, 6.0, 2.0);    // Declare box2
  28.    Box *ptrBox;                // Declare pointer to a class.
  29.    ptrBox = &Box1; // 保存第一个对象的地址
  30.    ptrBox = &Box2; // 保存第二个对象的地址
  32.    cout << "Volume of Box1: " << ptrBox->Volume() << endl;  // 现在尝试使用成员访问运算符来访问成员
  33.    cout << "Volume of Box2: " << ptrBox->Volume() << endl; // 现在尝试使用成员访问运算符来访问成员
  35.    return 0;
  36. }
  38. /* 
  39. Constructor called.
  40. Constructor called.
  41. Volume of Box1: 5.94
  42. Volume of Box2: 102 
  43. */

C++ 类的静态成员

我们可以使用 static 关键字来把类成员定义为静态的。当我们声明类的成员为静态时，这意味着无论创建多少个类的对象，静态成员都只有一个副本。
image.png
静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句，在创建第一个对象时，所有的静态数据都会被初始化为零。我们不能把静态成员的初始化放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化，如下面的实例所示。

静态成员变量

下面的实例有助于更好地理解静态成员数据的概念：

#include <iostream>
using namespace std;

class Box
{
   public:
      static int objectCount;
      // 构造函数定义
      Box(double l=2.0, double b=2.0, double h=2.0)
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // 每次创建对象时增加 1
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
   private:
      double length;     // 长度
      double breadth;    // 宽度
      double height;     // 高度
};

// 初始化类 Box 的静态成员
int Box::objectCount = 0;

int main(void)
{
   Box Box1(1.0, 2.0, 3.0);    // 声明 box1
   Box Box2(4.0, 5.0, 6.0);    // 声明 box2
   Box Box3(7.0, 8.0, 9.0);    // 声明 box3
   cout << "Total objects: " << Box::objectCount << endl; // 输出对象的总数
   return 0;
}

/* 
Constructor called.
Constructor called.
Constructor called.
Total objects: 3 
*/

静态成员函数

如果把函数成员声明为静态的，就可以把函数与类的任何特定对象独立开来。静态成员函数即使在类对象不存在的情况下也能被调用，静态函数只要使用类名加范围解析运算符 :: 就可以访问。
静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。
静态成员函数有一个类范围，他们不能访问类的 this 指针。您可以使用静态成员函数来判断类的某些对象是否已被创建。

静态成员函数与普通成员函数的区别：

  • 静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。
  • 普通成员函数有 this 指针，可以访问类中的任意成员；

下面的实例有助于更好地理解静态成员函数的概念：

#include <iostream>
using namespace std;

class Box
{
   public:
      static int objectCount;
      Box(double l=2.0, double b=2.0, double h=2.0)  // 构造函数定义
      {
         cout <<"Constructor called." << endl;
         length = l;
         breadth = b;
         height = h;
         // 每次创建对象时增加 1
         objectCount++;
      }
      double Volume()
      {
         return length * breadth * height;
      }
      static int getCount()
      {
         return objectCount;
      }
   private:
      double length;     // 长度
      double breadth;    // 宽度
      double height;     // 高度
};

// 初始化类 Box 的静态成员
int Box::objectCount = 0;

int main(void)
{
   // 在创建对象之前输出对象的总数
   cout << "Inital Stage Count: " << Box::getCount() << endl;
   Box Box1(1.0, 2.0, 3.0);    // 声明 box1
   Box Box2(4.0, 5.0, 6.0);    // 声明 box2
   Box Box3(7.0, 8.0, 9.0);    // 声明 box3
   // 在创建对象之后输出对象的总数
   cout << "Final Stage Count: " << Box::getCount() << endl;
   return 0;
}

/* 
Inital Stage Count: 0
Constructor called.
Constructor called.
Constructor called.
Final Stage Count: 3 
*/