C++继承的使用

定义

继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。

class Person
{
public:
void Print()
{
cout << "name:" << _name << endl;
cout << "age:" << _age << endl;
}
protected:
string _name = "peter"; // 姓名
int _age = 18; // 年龄
};

class Student : public Person
{
protected:
int _stuid; // 学号
};
class Teacher : public Person
{
protected:
int _jobid; // 工号
};
int main()
{
Student s;
Teacher t;
s.Print();
t.Print();
return 0;
}

这个代码里的Student和Teacher类都是Person的派生类，学生类和老师类都对Person类的成员变量和成员函数进行了复用。

如何定义继承 定义格式

此处Person是父类，也称基类，Student是子类，也称派生类。

继承关系与访问限定符

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

总结

1.基类private成员在派生类中无论以什么方式继承都是不可见的。

2.基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能
访问，就定义为protected。

可以看出保护成员限定符是因继承才出现的。

3.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的
写出继承方式。

4.在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用
protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中
扩展维护性不强。

5.只需记住基类中的private成员在任何继承方式下都是不可见的，剩下的成员看继承方式与基类中的访问方式哪个权限低就是它在派生类里的访问方式。

基类和派生类对象赋值转换

派生类对象可以赋值给基类的对象、指针及引用。

也称作切片或者切割。

基类对象不可以赋值给派生类对象。

基类的指针可以通过强制类型转换赋值给派生类的指针。

但是必须是基类的指针是指向派生类对象时才
是安全的。

class Person
{
protected :
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person
{
public :
int _No ; // 学号
};
void Test ()
{
Student sobj ;
// 1.子类对象可以赋值给父类对象/指针/引用
Person pobj = sobj ;
Person* pp = &sobj;
Person& rp = sobj;
//2.基类对象不能赋值给派生类对象
sobj = pobj;
// 3.基类的指针可以通过强制类型转换赋值给派生类的指针
pp = &sobj
Student* ps1 = (Student*)pp; // 这种情况转换时可以的。

ps1->_No = 10;
pp = &pobj;
Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问题
ps2->_No = 10;
}

继承中的作用域

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

• 2.子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。
  

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

• 4.注意在实际继承体系里尽量不要定义同名的成员。
  

// B中的fun和A中的fun不是构成重载，因为不是在同一作用域
// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。

class A
{
public:
void fun()
{
cout << "func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
A::fun();
cout << "func(int i)->" <<i<<endl;
}
};
void Test()
{
B b;
b.fun(10);
}

派生类的默认成员函数

• 1.派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。
  

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

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

• 3.派生类的operator=必须调用基类的operator=完成基类的复制。
  

• 4.派生类的析构函数会在调用完成后自动调用基类的析构函数清理基类成员。
  

  因为这样才能保证派生类对象先清理派生类成员再清理基类成员。
  

• 5.派生类对象初始化先调用基类构造再调用派生类构造。
  

• 6.派生类对象析构清理先调用派生类析构再调用基类析构。
  

class Person
{
public:
	Person(const char* name = "Peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}
	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}
	Person& operator=(const Person& p)
	{
		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)
		, _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 << "~Person()" << endl;
	}

protected:
	int _num;
};

void Test()
{
	Student s1("Jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
	s1 = s3;
}

继承与友元

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

class Student;
class Person
{
public:
	Person(const char* name = "person")
		: _name(name)
	{

	}
	friend void Display(const Person& p, const Student& s);
protected:
	string _name;
};

class Student : public Person
{
public:
	Student(const char* name = "stu", int num = 1)
		: Person(name)
		, _stuNum(num)
	{

	}
protected:
	int _stuNum;
};

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

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

静态成员继承

基类定义了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 _Course;
};

void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << "人数：" << Person::_count << endl;
	Student::_count = 0;
	cout << "人数：" << Person::_count << endl;
}

复杂的菱形继承及菱形虚拟继承

• 单继承：一个子类只有一个直接父类时称这个继承关系为单继承
  

• 多继承：一个子类有两个或以上直接父类时称这个继承关系为多继承
  

• 菱形继承：菱形继承是多继承的一种特殊情况
  
  菱形继承的问题：数据冗余和二义性

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;
};

void Test()
{
	Assistant a;
	a._name = "Jayce"; // 此处无法执行，必须指明类域
	// 指定类域可以解决二义性的问题，但无法解决数据冗余
	a.Student::_name = "Jay";
	a.Teacher::_name = "J";
}

int main()
{
	Test();
}

虚拟继承可以解决菱形继承的二义性和数据冗余的问题

class Person
{
public:
	string _name;
};

class Student : virtual public Person
{
protected:
	int _num;
};

class Teacher : virtual public Person
{
protected:
	int _id;
};

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse;
};

void Test()
{
	Assistant a;
	a._name = "Jayce";

	a.Student::_name = "Jay";
	a.Teacher::_name = "J";
}

int main()
{
	Test();
}

虚拟继承解决数据冗余和二义性的原理

这里需要使用内存窗口观察对象成员函数的模型

class A
{
public:
	int _a;
};

class B : virtual public A
{
public:
	int _b;
};

class C : virtual public A
{
public:
	int _c;
};

class D : public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	return 0;
}

上图是菱形虚拟继承的内存对象成员模型：D对象中将A放到了对象组成的最下面，这个A同时属于B和C，那么B和C如何去找到公共的A呢？这里是通过了B和C的两个指针，指向的一张表。

这两个指针叫虚基表指针，这两个表叫虚基表，虚基表中存的偏移量。

通过偏移量可以找到末尾的A。

那么在什么情况下D中的B和C部分要去找属于自己的A呢？下面这种赋值就需要

	D d;
	B b = d;
	C c = d;

继承和组合

• 继承是一种is-a的关系。
  

  也就是说每个派生类对象都是一个基类对象。
  

• 组合是一种has-a的关系，假设B组合了A，每个B对象中都有一个A对象。
  

• 优先使用对象组合。
  

• 继承允许根据基类的实现来定义派生类的实现。
  

  这种通过派生类的复用通常被称为白箱复用。
  

  术语“白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见。
  

  继承在一定程度上破坏了基类的封装，基类的改变，对派生类有很大的影响。
  

  派生类和基类间的依赖关系很强，耦合度高。
  

• 对象组合是类继承之外的另一种复用选择。
  

  新的更复杂功能可以通过组装或组合对象来获得。
  

  对象组合要求被组合的对象具有良好定义的接口。
  

  这种复用风格被称为黑箱复用，因为对象的内部细节是不可见的。
  

  对象只以”黑箱“的形式出现。
  

  组合类之间没有很强的依赖关系，耦合度低。
  

  优先使用对象组合有助于保持每个类被封装。