更多参考其他文档菜鸟文档、W3C、微软C++文档

继承和派生

继承和派生的概念

  • 继承：在定义以恶搞新的类B时，如果该类与某个已有的类A相似(指的是B拥有A的全部特点)，那么就可以把A作为一个基类，而把B作为基类的一个派生类(也称子类)。
  • 派生类是通过对基类进行修改和扩充得到的。在派生类中，可以扩充新的成员变量和成员函数。
  • 派生类一经定义后，可以独立适用，不依赖于基类。
  • 派生类拥有基类的全部成员函数和成员变量，不论是private、protected、public。
    • 在派生类的各个成员函数中，不能访问基类中的private成员。

需要继承的例子

派生类的写法


//语法
class 派生类名 ：public 基类名
{
    
};


//实例
class CStudent
{
    private:
    	string sName;
    	int nAge;
    public:
    bool IsThreeGood(){};
    void SetName(const string & name){sName = name;}
}

class CUndergraduateStudent:public CStudent{  
    //新的派生类包含基类的成员变量和函数
    private:
    	int nDepartment; //新增的成员变量
    public:
    	bool IsThreeGood(){}   //覆盖，相同的成员函数名就会覆盖基类中的
    	bool CanBaoYan(){};
};

class CGraduatedStudent:public CStudent{
    private:
    	int nDepartment;
    	char szMentorName[20];
    public:
    	int CountSalary(){};
};

派生类对象的内存空间

  • 派生类对象的体积，等于基类对象的体积，再加上派生类对象自己的成员变量的体积。在派生类对象中，包含着基类对象，而且基类对象的存储位置位于类派生类对象新增的成员变量之前。
class CBase
{
    int v1,v2;
};
class CDerived:public CBase
{
    int v3;
};
  • 派生类对象包含基类对象，派生类对象新增的内容位于基类对象之后
//实例
#include <iostream>
#include <string>
using namespace std;

class CStudent
{
private:
    string name;
    string id;
    char gender;
    int age;

public:
    void Printlnfo();
    void Setlnfo(const string &name_, const string &id_, int age_, char gender_);
    string GetName() { return name; }
};

class CUndergraduateStudent : public CStudent
{
private:
    string department;

public:
    void QualifiedForBaoyan()
    { //给予保研资格
        cout << "qualified for baoyan" << endl;
    }
    void printlnfo()
    {
        CStudent::Printlnfo(); //调用基类的Printlnfo
        cout << "Department:" << department << endl;
    }
    void Setlnfo(const string &name_, const string &id_, int age_, char gender_, const string &department_)
    {
        CStudent::Setlnfo(name_, id_, age_, gender_); //调用基类的Setinfo
        department = department_;
    }
};

int main()
{
    CUndergraduateStudent s2;
    s2.Setlnfo("Harray Potter", "118829212", 19, 'M', "Computer Science");
    cout << s2.GetName() << "";
    s2.QualifiedForBaoyan();
    s2.printlnfo();
    return 0;
}

继承关系和复合关系

  • 继承 “是”关系

    • 满足逻辑要求“ 一个B对象也是一个C对象”
    • 基类A，B是基类A的派生类

  • 复合 “有”关系

    • 类C中“有”成员变量k，k是类D的对象，则C和D是复合关系
    • 一般逻辑上要求：“D对象是C对象的固有属性或组成部分”

  • 继承关系使用

    • 人 对男人和女人 的关系，把人作为基类，男人和女人作为人的派生类

  • 复合关系使用

    • 需要“点”类，也需要“圆”类时，两者的关系就是复合关系，即每一个圆包含一个点

      //正确做法
      class CPoint
      {
          double x,y;
          friend class CCircle;
          //便于Ccirle类操作其圆心
      };

      class CCircle
      {
          double r;
          CPoint center;
      };

    • 小区业主与狗的关系

      //这样的定义是错的，循环定义了
      class CDog;
      class CMaster
      {
          CDog dogs[10];
      };

      class CDog
      {
          CMaster m;
      };


      //改进

      class CDog;
      class CMaster
      {
          CDog * dogs[10];  //CDog类的指针数组
      };
      class CDog{
          CMaster m;
      };
      //依然不行 在调用修改狗的主人的信息时，需要维持不同狗之间的一致性，比较繁琐

      //再次改进

      class CMaster; //先声明
      class CDog{
          CMaster *pm;
      };
      class CMaster{  
          //这样使得狗对象只能通过人来调用，失去了自由
          CDog dogs[10];
      };

      //正确做法
      class CMsater;

      class CDog{
          CMaster *pm;
      };
      class CMaster{
          CDog *dogs[10];  //这种关系也被称为"知道"
      };

派生类覆盖基类成员

  • 派生类可以定义一个和基类成员同名的成员，这叫做覆盖。== 在派生类中访问这类成员时，缺省的情况是访问派生类中定义的成员。要在派生类中访问由类定义的同名成员时，要使用作用域符号 ::

    class base//基类
    {
        int j;
        public:
        int i;
        void func();
    };

    class derived:public base//派生类
    {
        public:
        int i;
        void access();
        void func();
    };

    void derived::access() //派生类的成员函数
    {
        j=5; //这里是在派生类里找，错误error
        i=5; //派生类i
        base::i =5;  //基类i
        func();//派生类fun
        base::func();//基类fun
    }

    //注意
    一般来说，基类和派生类不定义同名的成员变量
    //占用空间
    |  base::j |
    |  base::i |
    |     i    |

类的保护成员

private:   //基类的成员函数、友元函数可以访问
public：   //基本上都可以访问
protected :  //基类的成员函数、友元函数、派生类的成员函数可以访问当前对象的基类的保护成员


class Father{
    private: int nPrivate;
    public: int nPublic;
    protected: int nProtected;
};
class Son: public Father{
    void AccessFatther()
    {
        nPublic =  1;//  ok
        nPrivate = 1 ; //wrong  访问了基类的私有成员
        nProtected = 1; // ok ，派生类可以访问基类的保护成员
        Son f;
        	f.nProtected = 1;  //wrong ,f不是当前对象
    }
};

int main()
{
    Father f;
    Son s;
    f.nPublic = 1;// OK
    s.nPublic = 1; //OK
    f.nProtected = 1; //error 保护
    f.nPrivate = 1;  //error  私有
    s.nProtected = 1;//error  保护
    s.nPrivate = 1;  //error  私有
    return 0;
}

派生类的构造函数

#include <iostream>
using namespace std;

class Bug  //基类
{
private:
	int nLegs;
	int nColor;

public:
	int nType;  //公有
	Bug(int legs, int color);
	void PrintBug(){};
};

class FlyBug : public Bug  //派生类
{
	int nWings;
public:
	FlyBug(int legs, int color, int wings);
};

Bug::Bug(int legs, int color)
{
	nLegs = legs;
	nColor = color;
}


//错误 的派生类构造函数
FlyBug::FlyBug(int legs, int color, int wings)//派生类成员函数
{
	nLegs = legs;  //访问的是基类的私有成员数据  错误
	nColor = color;   //访问的是基类的私有成员数据  错误
	nType = 1;  //访问基类的公有成员  
	nWings = wings;  //自己的私有成员
}
//正确 的派生类构造函数
FlyBug::FlyBug(int legs,int color,int wings):Bug(legs,color)
{
    nWings = wings;
}


FlyBug::FlyBug(int legs, int color, int wings) : Bug(legs, color)
{
	nWings = wings;
}

int main()
{
	FlyBug fb(2, 3, 4);
	fb.nType = 1;
	fb.nLegs = 2;  //这里同样不能调用基类的私有成员  错误
	return 0;
}
//在一个派生类的构造函数被执行之前，总是先执行基类的构造函数
//相反，在派生类的析构函数被执行时，执行完派生类的析构函数后，自动调用基类的构造函数

  • 调用基类构造函数的两种方式

    • 显示方式：在派生类的构造函数中，为基类的构造函数提供参数

      derived::derived(arg_derived-list):base(arg_base-list)

    • 隐式方式：在派生类的构造函数中，省略基类构造函数时，派生类的构造函数则自动调用基类的默认构造函数。

包含成员对象的派生类的构造函数写法

class Bug{
    private:
    int nLegs;
    int nColor;
    public:
    int nType;
    Bug(int legs,int color);
    void PrintBug(){};
};

class SKill
{
    public: 
    Skill(int n){}
};

class FlyBug:public Bug{
    int nWings;
    Skill sk1,sk2;
    public:FlyBug(int legs,int color, int wings);
};
FlyBug::FlyBug(int legs,int color, int wings):
	Bug(legs,color),sk1(5),sk2(color),nWings(wings){}

生成时：

  • 先执行基类的构造函数，用以初始化派生类对象中的从基类继承的成员；
  • 在执行成员对象类的构造函数，用以初始化派生类对象中成员对对象。
  • 最后指向派生类自己的析构函数

消亡时：

  • 先执行派生类自己的析构函数
  • 再一次执行各成员对象类的析构函数
  • 最后执行基类的析构函数

析构函数的调用顺序与构造函数的调用顺序相反

public 继承的赋值兼容规则

class base{};
class derived:public base{};
base b;
derived d;

  • 派生类对象可以赋值给基类对象

    b = d;

  • 派生类对象可以初始化基类引用

    base & br = d;

  • 派生类对象的地址可以赋值给基类指针

    base * pb = & d;

直接基类与间接基类

A－派生－Ｂ－派生－Ｃ

Ａ是B的直接基类，Ａ是Ｃ的间接基类

  • 声明派生类时,只需要列出它的直接基类
    • 派生类沿着类的层次自动向上继承它的间接基类
  • 派生类的成员包括
    • 派生类自己定义的成员
    • 直接基类中的所有成员
    • 所有间接基类的全部成员
#include<iostream>

using namespace std;

class Base{
	public:
		int n;
		Base(int i):n(i)
		{
			cout << "Base" << n << "constructed" << endl;
		}
		~Base(){
			cout << "Base" << n << "dextructed" << endl;
		}
};
class Derived:public Base
{
	public:
	Derived(int i):Base(i){
		cout << "Derived costructed" << endl;
	}
	~Derived()
	{
		cout << "Derived dsetucted" << endl;
	}
};

class MoreDerived:public Derived
{
	public:
	MoreDerived():Derived(4)  //只用写明直接基类的成员赋值就行，不需要写间接基类
	{
		cout << "More Derived constructed" << endl;
	}
	~MoreDerived()
	{
		cout << "More Derived destructed" << endl;
	}
};

int main()
{
	MoreDerived Obj;  //从最顶层基类开始构造
	return 0;
}  //先析构最后派生的类