继承2...

继承与友元

• 友元关系不能被继承，父类和子类的友元要分别去处理

class Student;
class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};
class Student : public Person
{
	friend void Display(const Person& p, const Student& s);
protected:
	int _stuNum; // 学号
};
void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._stuNum << endl;
}
void main()
{
	Person p;
	Student s;
	Display(p, s);
}

继承静态成员变量

• 基类静态成员，属于整个继承体系的类，属于这些类的所有对象,可以使用Person、student、任意对象(s4)来访问
• 静态成员不会被继承下来(即不会重复的在子类中再写一个count的成员变量)，子类和父类共用父类的count
• 在执行的过程中子类初始化父类的部分会调用父类的构造函数来初始化，即在student执行中会++count

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; // 研究科目
};
void main()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " 人数 :" << Person::_count << endl;//4
	Person p;
	cout << " 人数 :" << Person::_count << endl;//5
	cout << " 人数 :" << Student::_count << endl;
	cout << " 人数 :" << s4._count << endl;
	/*Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;*/
}

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

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

多继承是C++的一个坑，但是早期设计不知道，没办法。
在设计的时候最好不使用菱形继承

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; // 主修课程
};
int main()
{
	Assistant a;
	//a._name = "张三"--没有virtual的时候会err,因为不能够指定是指向student还是teacher
	a.Student::_name = "张三-学生";
	a.Teacher::_name = "张三-老师";
	a._name = "张三";
	return 0;//加了virtual就解决了二义性的问题
}

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;

	d._a = 0;

	B b;
	b._a = 1;
	b._b = 2;

	B* p = &b;
	p->_a = 3;
	p = &d;
	p->_a = 4;

	return 0;
}

组合和继承

模块(类…)之间的关联度越高，耦合度越高，独立性越高
推崇低耦合高内聚
耦合度越低越好，组合的耦合度较低

当类的关系为is-a的时候用继承，public继承是一种is-a的关系
当类的关系为has-a的时候用组合，组合是一种has-a的关系