12.c++面向对象——类与对象，成员函数，继承，构造&析构，友元函数，this指针，类的静态成员

一.C++类的定义

定义一个类，本质上是定义一个数据类型的蓝图。

类定义是以关键字 class 开头，后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。例如，我们使用关键字 class 定义 Box 数据类型，如下所示：

class Box
{
   
   
   public:
      double length;   // 盒子的长度
      double breadth;  // 盒子的宽度
      double height;   // 盒子的高度
};

关键字 public 确定了类成员的访问属性。在类对象作用域内，公共成员在类的外部是可访问的。您也可以指定类的成员为 private 或 protected。

二. C++对象

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

Box Box1;          // 声明 Box1，类型为 Box
Box Box2;          // 声明 Box2，类型为 Box

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

class Box
{
   
   
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
};
 
int main( )
{
   
   
   Box Box1;        // 声明 Box1，类型为 Box
   Box Box2;        // 声明 Box2，类型为 Box
   double volume = 0.0;     // 用于存储体积
 
   // box 1 详述
   Box1.height = 5.0;
   Box1.length = 6.0;
   Box1.breadth = 7.0;
   return 0；
   }

三.类的成员函数

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

class Box
{
   
   
   public:
      double length;         // 长度
      double breadth;        // 宽度
      double height;         // 高度
      double getVolume(void);// 返回体积
};

内联函数

C++ 内联函数是通常与类一起使用。如果一个函数是内联的，那么在编译时，编译器会把该函数的代码副本放置在每个调用该函数的地方。
内联的主要不同是：它会复制源函数代码到调用的位置，而不像普通函数一样进行现场保护、跳转执行然后恢复现场等操作，可以使程序效率提高。

成员函数可以定义在类定义内部，在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。所以您可以按照如下方式定义 Volume() 函数：

class Box
{
   
   
   public:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度

      double getVolume(void)
      {
   
   
         return length * breadth * height;
      }
};

也可以在类的外部使用范围解析运算符 :: 定义该函数，在这里，需要强调一点，在 :: 运算符之前必须使用类名。如下所示：

double Box::getVolume(void)
{
   
   
    return length * breadth * height;
}

调用成员函数是在对象上使用点运算符（.），这样它就能操作与该对象相关的数据，如下所示：

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

3.1C++ 类访问修饰符

数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问修饰符。
一个类可以有多个 public、protected 或 private 标记区域。每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。成员和类的默认访问修饰符是 private。

class Base {
   
   

   public:

  // 公有成员

   protected:

  // 受保护成员

   private:

  // 私有成员

};

3.2私有成员：

私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。
举例：
默认情况下，类的所有成员都是私有的。例如在下面的类中，width 是一个私有成员，这意味着，如果您没有使用任何访问修饰符，类的成员将被假定为私有成员：

class Box
{
   
   
   double width;
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );
};

实际操作中，我们一般会在私有区域定义数据，在公有区域定义相关的函数，以便在类的外部也可以调用这些函数，如下所示：
width是一个private变量，我们不可以再main函数中box.width直接访问它，但是我们可以定义一个Public函数 setwidth，用这个共有的函数来访问私有的变量。

void Box::setWidth( double wid )
{
   
   
    width = wid;
}

即：

#include <iostream>

using namespace std;

class Box
{
   
   
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );

   private:
      double width;
};

// 成员函数定义
double Box::getWidth(void)
{
   
   
    return width ;
}

void Box::setWidth( double wid )
{
   
   
    width = wid;
}

// 程序的主函数
int main( )
{
   
   
   Box box;

   // 不使用成员函数设置长度
   box.length = 10.0; // OK: 因为 length 是公有的
   cout << "Length of box : " << box.length <<endl;

   // 不使用成员函数设置宽度
   // box.width = 10.0; // Error: 因为 width 是私有的
   box.setWidth(10.0);  // 使用成员函数设置宽度
   cout << "Width of box : " << box.getWidth() <<endl;

   return 0;
}

3.3保护成员：

1.private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；
2.protected 成员可以被派生类访问。
保护（protected）成员变量或函数与私有成员十分相似（即也不可以在类外访问protected变量），但有一点不同，保护成员在派生类（即子类）中是可访问的。
现在您可以看到下面的实例中，我们从父类 Box 派生了一个子类 smallBox。
下面的实例与前面的实例类似，在这里 width 成员可被派生类 smallBox 的任何成员函数访问。

#include <iostream>
using namespace std;

class Box
{
   
   
   protected:
      double width;
};

class SmallBox:Box // SmallBox 是派生类
{
   
   
   public:
      void setSmallWidth( double wid );
      double getSmallWidth( void );
};

// 子类的成员函数
double SmallBox::getSmallWidth(void)
{
   
   
    return width ;
}

void SmallBox::setSmallWidth( double wid )
{
   
   
    width = wid;
}

// 程序的主函数
int main( )
{
   
   
   SmallBox box;

   // 使用成员函数设置宽度
   box.setSmallWidth(5.0);
   cout << "Width of box : "<< box.getSmallWidth() << endl;

   return 0;
}

四.继承

有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。

1. public 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：public, protected, private（即没变化）
2. protected 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：protected, protected, private（除了private其他全被protect,意味着不能类外访问)
3. private 继承：基类 public 成员，protected 成员，private 成员的访问属性在派生类中分别变成：private, private, private(全被private)

但无论哪种继承方式，下面两点都没有改变：

1. private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；
2. protected 成员可以被派生类访问。

下面举三种继承的例子：

4.1public继承

注意：基类的private成员不能被派生类访问（a3）

#include<iostream>
#include<assert.h>
using namespace std;

//定义A类
class A{
   
   
public:
  int a;
  A()
  {
   
   
    a1 = 1;
    a2 = 2;
    a3 = 3;
    a = 4;
  }
  void fun(){
   
   
    cout << a << endl;    //正确
    cout << a1 << endl;   //正确
    cout << a2 << endl;   //正确
    cout << a3 << endl;   //正确
  }
public:
  int a1;
protected:
  int a2;
private:
  int a3; //注意private成员不能被派生的子类访问
};
//end A

//class B public继承A ，中间打冒号即可
class B : public A{
   
   
public:
  int a;