C++ -继承

目录

一、继承的概念及定义

1.继承的概念

2.继承的定义

3.继承关系和访问限定符

4.继承基类成员访问方式的变化

二、基类和派生类对象的赋值转换

三、继承中的作用域

1.成员的隐藏

2.成员函数的隐藏

四、派生类的默认成员函数

1.构造函数

2.拷贝构造函数

3.operator=

4.析构函数

五、继承与友元、静态成员的关系

1.继承和友元

2.继承和静态成员

六、多继承、菱形继承和虚拟继承

1.单继承和多继承

2.菱形继承

3.虚拟继承

七、继承和组合

1.黑盒和白盒

 

一、继承的概念及定义

1.继承的概念

• 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。

class Person
{
public:
	void print()
	{
		cout << "姓名:" << _name << endl;
		cout << "年龄:" << _age << endl;
	}
protected:
	int _age = 18;
	string _name = "小王";
};

class Student : public Person
{
protected:
	int student_id;
};

int main()
{
	Student s1;
	s1.print();
	return 0;
}

这里我们可以看到：Student类(子类)继承了父类(Person)后，父类的Person的成员（成员函数+成员变量）都会变成子类的一部分。这里体现出了 Student复用了Person的成员。

2.继承的定义

基类也叫父类，派生类也叫子类

3.继承关系和访问限定符

4.继承基类成员访问方式的变化

总结：

1. 基类private成员在派生类中无论以什么方式继承都是不可见的。
2. 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。
3. 实际上面的表格我们进行一下总结会发现，基类的私有成员在派生类都是不可见。基类的其他成员 在派生类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private。这句话怎么理解呢？就是说基类的成员，他的访问方式是什么，去对比派生类的继承方式，哪个小那么基类在派生内中的访问方式就是哪个。
4. 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

二、基类和派生类对象的赋值转换

public继承的派生类对象可以赋值给基类的指针/基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中基类那部分切出来，基类指针或引用指向的是派生类中切出来的基类那部分。基类对象不能赋值给派生类对象。

class Person
{
protected :
    string _name; // 姓名
    string _sex; // 性别
    int _age; // 年龄
};

class Student : public Person
{
public :
    int _No ; // 学号
};

int main()
{
    Student sobj ;
    // 1.派⽣类对象可以赋值给基类的指针/引⽤
    //切片
    Person* pp = &sobj;
    Person& rp = sobj;
 
    //子类对象可以赋值给基类的对象，是通过调⽤基类的拷⻉构造完成的
    Person pobj = sobj;
 
    //2.基类对象不能赋值给派⽣类对象，这⾥会编译报错
    sobj = pobj;
    return 0;
}

三、继承中的作用域

1.在继承体系中基类和派生类都有独立的作用域。

2. 派生类和基类中有同名成员，派生类成员将屏蔽基类对同名成员的直接访问，这种情况叫隐藏。（在派生类成员函数中，可以使用基类::基类成员显示访问）

3. 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。

4. 注意在实际中在继承体系里面最好不要定义同名的成员。

注意：他和重载的区别，重载是要在一个作用域里面的，而他是在两个独立的作用域里面的，一旦基类被隐藏了，就无法通过派生类去访问到基类。

1.成员的隐藏

class Person
{
protected:
	int _age = 18;
	string _name = "小王";
};

class Student : public Person
{
public:
	void print()
	{
		cout << "姓名:" << _name << endl;
		cout << "年龄:" << _age << endl;
	}
protected:
	string _name="小张";
};

int main()
{
	Student s1;
	s1.print();
	return 0;
}

基类和派生类都有共同的成员_name，所以构成隐藏。系统会优先查找派生类的作用域，但是如果你想要用基类的成员的话，可以显示访问。

cout << "姓名:" << Person::_name << endl;

2.成员函数的隐藏

class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};

class B: public A
{
public:
	void fun(int i)
	{
		cout << "func(int i)" << endl;
	}
};

int main()
{
	B b;
	b.fun();
	return 0;
}

这个程序就会出现编译报错，因为子类和父类的函数名相同，所以构成隐藏，B对象无法通过子类去访问到父类，所以就会编译报错。

四、派生类的默认成员函数

1.构造函数

派生类的构造顺序：1.基类的默认构造（全缺省、无参、系统自己生成的默认构造）

                                 2.构造派生类的自定义类型和内置类型

派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认 的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。

class Person
{
public:
	Person(const char* name="小张")//构造函数
		:_name(name)
	{
		cout << "Person()" << endl;
		cout << "姓名:" <<_name<< endl;
	}
protected:
	string _name;
};

class Student: public Person
{
public:
	Student(const char* name, int num)
		:Person(name)//因为派生类没有_name,所以要用基类的
		,_num(num)
	{
		cout << "Student()" << endl;
		cout << "姓名:" << _name << endl;
		cout << "学号:" << _num << endl;
	}
protected:
	int _num;//学号
};

int main()
{
	Student s1("小李",20);
	return 0;
}

2.拷贝构造函数

派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。

class Person
{
public:
	Person(const char* name="小张")//构造函数
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)//拷贝构造
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
protected:
	string _name;
};

class Student: public Person
{
public:
	Student(const char* name, int num)
		:Person(name)//因为派生类没有_name,所以要用基类的
		,_num(num)
	{
		cout << "Student()" << endl;
	}
	Student(const Student& s)
		:Person(s)
		,_num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}
protected:
	int _num;//学号
};

int main()
{
	Student s1("小李",20);
	Student s2(s1);
	return 0;
}

3.operator=

派生类的operator=必须要调用基类的operator=完成基类的复制。需要注意的是派生类的 operator=隐藏了基类的operator=，所以显示调用基类的operator=，需要指定基类作用域

class Person
{
public:
	Person(const char* name="小张")//构造函数
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)//拷贝构造
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person& p) //operator=重载
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}
protected:
	string _name;
};

class Student: public Person
{
public:
	Student(const char* name, int num)
		:Person(name)//因为派生类没有_name,所以要用基类的
		,_num(num)
	{
		cout << "Student()" << endl;
	}
	Student(const Student& s)
		:Person(s)
		,_num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}
	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator =(s);
			_num = s._num;
		}
		return *this;
	}
protected:
	int _num;//学号
};

int main()
{
	Student s1("小李",20);
	Student s2(s1);
	return 0;
}

4.析构函数

派生类的析构函数会在被调用完成后，自动调用基类的析构函数清理基类成员。因为这样才能保证派生类对象先清理，派生类成员再清理基类成员的顺序。派生类对象析构清理先调用派生类析构再调基类的析构

因为后续一些场景析构函数需要构成重写，重写的条件之一是函数名相同(这个我们后面会讲 解)。那么编译器会对析构函数名进行特殊处理，处理成destrutor()，所以父类析构函数不加 virtual的情况下，子类析构函数和父类析构函数构成隐藏关系。

class Person
{
public:
	Person(const char* name="小张")//构造函数
		:_name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)//拷贝构造
		:_name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person& p) //operator=重载
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}
	~Person() //析构函数
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name;
};

class Student: public Person
{
public:
	Student(const char* name, int num)
		:Person(name)//因为派生类没有_name,所以要用基类的
		,_num(num)
	{
		cout << "Student()" << endl;
	}
	Student(const Student& s)
		:Person(s)
		,_num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}
	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator =(s);
			_num = s._num;
		}
		return *this;
	}
	~Student()
	{
		cout << "~Student()" << endl;//不用调用基类的析构函数，程序会自己调用
	}

protected:
	int _num;//学号
};

int main()
{
	Student s1("小李",20);
	Student s2(s1);
	Student s3("小张", 19);
	return 0;
}

注：基类的析构函数~Person()和派生类的析构函数~Student()虽然名字不同，但是底层会变为 destrutor()，构成隐藏。

五、继承与友元、静态成员的关系

1.继承和友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员

class Student;
class Person
{
public:
    friend void Display(const Person& p, const Student& s);
protected:
    string _name; // 姓名
};

class Student : public Person
{
protected:
    int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
    cout << p._name << endl;
    cout << s._stuNum << endl;
}

int main()
{
   Person p;
   Student s;
   Display(p, s);
   return 0;
}

2.继承和静态成员

基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子 类，都只有一个static成员实例 。

class Person
{
public:
	Person() { ++_count; }
protected:
	string _name; // 姓名
public:
	static int _count; // 统计人的个数。
};

int Person::_count = 0;

class Student : public Person
{
protected:
	int _stuNum; // 学号
};

class Graduate : public Student
{
protected:
	string _seminarCourse; // 研究科目
};

int main()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " 人数 :" << Person::_count << endl;
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;
	return 0;
}

六、多继承、菱形继承和虚拟继承

1.单继承和多继承

单继承：一个派生类只有一个直接基类时称这个继承关系为单继承

多继承：一个派生类有两个或以上直接基类时称这个继承关系为多继承，多继承对象在内存中的模型是，先继承的基类在前面，后⾯继承的基类在后面，派生类成员在放到最后面。

2.菱形继承

菱形继承：菱形继承是多继承的一种特殊情况。从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题，支持多继承就一定会有菱形继承，像Java就直接不支持多继承，规避掉了这里的问题，所以实践中我们也是不建议设计出菱形继承这样的模型。

class Person
{
public:
    string _name; // 姓名
};
 
class Student : public Person
{
protected:
    int _num; //学号
};
 
class Teacher : public Person
{
protected:
    int _id; // 职⼯编号
};
 
class Assistant : public Student, public Teacher
{
protected:
    string _majorCourse; // 主修课程
};
 
int main()
{
    // 编译报错：error C2385: 对“_name”的访问不明确
    Assistant a;
    a._name = "peter";

    // 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
    a.Student::_name = "xxx";
    a.Teacher::_name = "yyy";
    return 0;
}

(我们可以看到在Assistant的对象中Person成员会有两份，这就是继承的冗余)

3.虚拟继承

虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和 Teacher的继承Person时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用。

使用方法：class 派生类名：virtual 继承方式 基类名

// 使⽤虚继承Person类
class Student : virtual public Person
{
protected:
   int _num; //学号
};
// 使⽤虚继承Person类
class Teacher : virtual public Person
{
protected:
   int _id; // 职⼯编号
};

注意：哪个类产生了数据冗余和二义性，继承时用虚继承。

七、继承和组合

• 继承：public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
• 组合：组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

举例

// Car和BMW Car和Benz构成is-a的关系
class Car
{
protected:
   string _colour = "白色"; // 颜色
   string _num = "陕ABIT00"; // 车牌号
};
   
class BMW : public Car
{
public:
   void Drive() {cout << "好开-操控" << endl;}
};
   
class Benz : public Car
{
public:
   void Drive() {cout << "好坐-舒适" << endl;}
};
   
   
// Tire和Car构成has-a的关系
   
class Tire
{
protected:
    string _brand = "Michelin";  // 品牌
    size_t _size = 17;         // 尺寸
   
};
   
class Car
{
protected:
   string _colour = "白色"; // 颜色
   string _num = "陕ABIT00"; // 车牌号
   Tire _t; // 轮胎
}; 

1.黑盒和白盒

• 黑盒测试：不了解底层，实现从功能角度测试。组合属于黑盒复用，依赖关系低，耦合度低。

• 白盒测试：了解底层，实现从代码运行逻辑角度测试。继承属于白盒复用，依赖关系高，耦合度高。

优先使用组合，而不是继承。实际尽量多去用组合，组合的耦合度低，代码维护性好。不过也不太那么绝对，类之间的关系就适合继承(is-a)那就用继承，另外要实现多态，也必须要继承。类之间的关系既适合用继承(is-a)也适合组合(has-a)，就用组合。

 stack和vector的关系，既符合is-a，也符合has-a，所以都可以使用

//is-a
template<class T>
class stack : public vector<T>
{};

//has-a
template<class T>
class stack
{
public:
   vector<T> _v;
};