1、继承的定义
继承是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类称派生类。
#include<iostream>
using namespace std;
class Person
{
public:
Person(const string& name = "", const int& age = 0)
:_name(name), _age(age)
{}
void Print()
{
cout<<"name:"<<_name<<endl;
cout<<"age:"<<_age<<endl;
}
protected:
string _name;
int _age;
};
class Student:public Person
{
public:
Student(const string& name = "", const int& age = 0, const int& sid = 0)
:Person(name, age), _sid(sid)
{}
void Print()
{
Person::Print();
cout<<"sid:"<<_sid<<endl;
}
protected:
int _sid;
};
class Teacher:public Person
{
public:
Teacher(const string& name = "", const int& age = 0, const int& tid = 0)
:Person(name, age), _tid(tid)
{}
void Print()
{
Person::Print();
cout<<"tid:"<<_tid<<endl;
}
protected:
int _tid;
};
int main()
{
Student s("a", 22, 1111);
Teacher t("b", 24, 2222);
s.Print();
t.Print();
return 0;
}
继承基类成员访问方式的变化
- 基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
- 基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。
- 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
- protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。
2、基类和派生类对象赋值转换
- 派生类对象可以赋值给基类的对象/基类的指针/基类的引用。
- 基类对象不能赋值给派生类对象。
- 基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。
- 基类如果是多态类型，可以使用RTTI(Run-Time Type Information)的dynamic_cast 来进行识别后进行安全转换。
#include<iostream>
using namespace std;
class Person
{
protected:
string _name;
string _sex;
int _age;
};
class Student:public Person
{
public:
int _no;
};
int main()
{
Student sobj;
//子类对象赋值给父类对象/指针/引用
Person pobj = sobj;
Person* ppobj = &sobj;
Person& rpobj = sobj;
//sobj = pobj;基类对象不能赋值给派生类对象
//基类的指针可以通过强制类型装换赋值给派生类指针
ppobj = &sobj;
Student* psobj1 = (Student *)ppobj;
psobj1->_no = 123;
//有时可能会出现越界访问
ppobj = &pobj;
Student* psobj2 = (Student *)ppobj;
psobj2->_no = 234;
return 0;
}
3、继承的作用域
- 在继承体系中基类和派生类都有独立的作用域。
- 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。(在子类成员函数中，可以使用"基类::基类成员"显示访问)
- 如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
- 在实际中在继承体系里面最好不要定义同名的成员。
4、派生类的默认成员函数
6个默认成员函数编译器会自己生成：构造函数、析构函数、拷贝构造、赋值重载、普通对象取地址、const对象取地址
#include<iostream>
using namespace std;
class Person
{
public:
Person(const char * name = "Tom")
:_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<<"~Student()"<<endl;
}
protected:
int _num;
};
int main()
{
Student s1("a", 20);
Student s2(s1);
Student s3 = s1;
return 0;
}
- 派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员。如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显示调用。
- 派生类的拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化。
- 派生类的operator=必须要调用基类的operator=完成基类的复制。
- 派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员。这样才能保证派生类对象先清理派生类成员，再清理基类成员的顺序。
- 派生类对象初始化先调用基类构造再调派生类构造。派生类对象析构清理先调用派生类析构再调基类的析构。
实现一个不能被继承的类
#include<iostream>
using namespace std;
class NonInher
{
public:
static NonInher GetInstance()
{
return NonInher();
}
private:
NonInher()
{}
};
/*C++11:final关键字禁止继承
class NonInher final
{};
*/
/*
class Test:public NonInher
{};
*/
int main()
{
return 0;
}
5、继承和友元
友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员
#include<iostream>
using namespace std;
class Student;
class Person
{
public:
friend void display(const Person& p, const Student& s);
protected:
string _name;
};
class Student:public Person
{
protected:
string _sno;
};
void display(const Person& p, const Student& s)
{
cout<<p._name<<endl;
//cout<<s._sno<<endl;
}
int main()
{
Person p;
Student s;
display(p, s);
return 0;
}
6、继承和静态成员
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。
#include<iostream>
using namespace std;
class Person
{
public:
Person()
{
++_count;
}
protected:
string _name;
public:
static int _count;
};
int Person::_count = 0;
class Student:public Person
{
protected:
string _sno;
};
class Graduate:public Student
{
protected:
string _course;
};
int main()
{
Person p;
Student s1;
Student s2;
Graduate g1;
Graduate g2;
cout<<"Person Number:"<<Person::_count<<endl;//5
Student::_count = 0;
cout<<"Person Number:"<<Person::_count<<endl;//0
return 0;
}
7、复杂的菱形继承和菱形虚拟继承
单继承：一个子类只有一个直接父类
class Person{};
class Student:public Person{};
class Graduate:public Student{};
多继承：一个子类有两个及以上直接父类
class Student{};
class Teacher{};
class Assistant:public Student,public Teacher{};
菱形继承：多继承的特殊情况
class Person{};
class Student:public Person{};
class Teacher:public Person{};
class Assistant:public Student,public Teacher{};
菱形继承的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。在Assistant的对象中Person成员会有两份。
#include<iostream>
using namespace std;
class Person
{
public:
string _name;
};
class Student:public Person
{
protected:
string _num;
};
class Teacher:public Person
{
protected:
string _id;
};
class Assistant:public Student,public Teacher
{
protected:
string _majorCourse;
};
int main()
{
Assistant ass;
//ass._name = "a";二义性无法明确
ass.Student::_name = "x";
ass.Teacher::_name = "y";
return 0;
}
虚拟继承
虚拟继承可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在Student和Teacher的继承Person时使用虚拟继承，即可解决问题。
#include<iostream>
using namespace std;
class Person
{
public:
string _name;
};
class Student:virtual public Person
{
protected:
string _num;
};
class Teacher:virtual public Person
{
protected:
string _id;
};
class Assistant:public Student,public Teacher
{
protected:
string _majorCourse;
};
int main()
{
Assistant ass;
ass._name = "a";
return 0;
}
菱形虚拟继承原理
8、小结
继承和组合
- public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
- 组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。
- 优先使用对象组合，而不是类继承。
- 继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用。在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
- 对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口，这种复用风格被称为黑箱复用。因为对象的内部细节是不可见的，对象只以“黑箱”的形式出现，组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于保持每个类被封装。
- 实际尽量多去用组合。组合的耦合度低，代码维护性好。类之间的关系可以用继承也可以用组合，就用组合。但是要实现多态，也必须要继承。
#include<iostream>
using namespace std;
//A、B构成is-a关系
class A
{
protected:
string _a = "_a";
};
class B:public A
{
public:
void display()
{
cout<<_a<<_b<<endl;
}
protected:
string _b = "_b";
};
//C、D构成has-a关系
class C
{
public:
string get_c()
{
return _c;
}
protected:
string _c = "_c";
};
class D
{
public:
void display()
{
cout<<c.get_c()<<_d<<endl;
}
protected:
string _d = "_d";
C c;
};
int main()
{
B b;
b.display();
D d;
d.display();
return 0;
}
