1、继承的相关概念：
继承是不修改已存在的类，而是采取这个已存在类的形式，并将代码加入其中的方法，是面向对象复用的重要手段。继承的语法是：在代码中和原来一样给出该类的名字，但是在左括号的前面加一个冒号和基类的名字（对于多重继承，要给出多个基类名，用逗号隔开）。
（1）派生类将继承基类的数据和函数
【例】
class A //基类（父类）
{
public:
void Func1(void);
void Func2(void);
int i = 100;
};
class B :public A //子类（派生类），继承关系是public
{
public:
void Func3(void);
void Func4(void);
};
int main()
{
B b;
b.i; //B从A继承数据i
b.Func1();//B从A继承函数func1()
b.Func2();//B从A继承函数func2()
b.Func3();
b.Func4();
}（2）继承可以调用基类的函数来实现自己的函数。
【例】
class A
{
public:
void Func1(void);
void Func2(void);
};
class B : public A //B继承A
{
public:
void Func3(void)
{
A::Func1();//先调用基类的函数（1.为何要调用而不直接引用？？？）
... //自己的实现代码
}
void Func4(void)
{
... //自己的实现代吗
A::Func2(); //后调用基类的函数
}
};2、成员访问限定符与继承的关系
如图1：
图1 成员访问限定符与继承的关系
三种继承关系下基类成员在派生类的访问关系变化，如表1：
表1 继承与基类成员在派生类中的访问关系表
总结：
1）基类的私有成员在派生类中不能被访问，如果一些基类成员不想被基类对象直接访问，可以定义为保护成员。
2）public继承是一个接口继承，保持is-a原则（2.是什么？？），每个父类可用的成员对子类也可用，因为每个子类对象也是一个父类对象。
3）protect/private继承基类的部分成员并未成为子类的一部分，是has-a的关系原则（3.是什么？？），这种继承关系很少用，一般用public继承关系。
4）不管哪种继承关系，在派生类内部都可以访问基类中的公有成员和保护成员，但是子类中的成员不能访问父类中的私有成员。
5）使用struct时的默认继承关系是public,而class时的默认继承关系是private，最好是把继承方式写出来。
3、继承与转换
1）子类对象可以赋值给父类对象。
2）父类对象不可以赋值给子类对象。
3）父类对象的指针和引用可以指向子类对象。
4）子类对象的指针和引用不能指向父类对象，但是可以通过强制转化完成。
【例】
class Person
{
public:
void Display()
{
cout << _name << endl;
}
protected:
string _name;
};
class Student : public Person
{
public:
int _num;
};
void Test()
{
Person p;
Student s;
//子类对象可以赋值给父类对象
p = s;
//父类对象不可以赋值给子类对象
//s = p;//error
//父类对象的指针和引用可以指向子类对象
Person *p1 = &s;
Person& r1 = s;
//子类对象的指针和引用不能指向父类的对象(但是可以通过强制类型转化完成)
Student *p2 = (Student*)&p;
Student& r2 = (Student&)p;
}4、继承体系中的作用域
（1）在继承体系中基类和派生类都有独立的作用域。
（2）子类和父类中有同名成员，子类成员将屏蔽父类成员的直接访问。（在子类成员函数中，可以使用基类：：基类成员访问）
（3）注意尽量不要在继承体系中定义同名的成员。
【例】
class Person
{
public:
Person(const char* name = "", int id = 0)
:_name(name)
, _num(id)
{}
protected:
string _name; //姓名
int _num; //身份证
};
class Student : public Person
{
public:
Student(const char *name, int id, int stuNum)
:Person(name, id)
, _num(stuNum)
{}
void DisplayNum()
{
cout << "身份证：" << Person::_num << endl;
cout << "学号" << _num << endl;
}
protected:
int _num; //学号
};
void Test()
{
Student s1("paul", 110, 1);
s1.DisplayNum();
}
int main()
{
Test();
system("pause");
return 0;
}4、派生类的默认成员函数
在继承关系里，派生类中如果没有显示定义这六个成员函数，编译系统则会默认合成六个成员函数，即构造函数、拷贝构造函数、析构函数、赋值操作符重载、取地址操作符重载、const修饰的取地址操作符重载。
【例】
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)
{
cout << "Person operatpr = (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;
}
private:
int _num; //学号
};
void Test()
{
Student s1("jack", 18);
Student s2(s1);
Student s3("rose", 17);
s1 = s3;
}
int main()
{
Test();
system("pause");
return 0;
}5、单继承和多重继承
（1）单继承：一个子类只有一个直接父类
（2）多继承：一个子类有两个或以上个直接父类
如图2：
图2 单继承与多继承图
6、菱型继承
如图3：
图3 菱形继承图
菱形继承对象模型，如图4：
图4 菱形继承对象模型图
【例】
//菱形继承
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 _majorCorse; //主修课程
};
void Test()
{
Assistant a;
a.Student::_name = "xxx";
a.Teacher::_name = "yyy";
}
int main()
{
Test();
system("pause");
return 0;
}7、友元与继承
友元关系不能继承，也就是说基类友元不能访问子类私有和保护的成员。
【例】
//友元与继承
class Person
{
friend void Display(Person& p, Student& s);
protected:
string _name; //姓名
};
class Student : public Person
{
protected:
int _stuNum; //学号
};
void Display(Person& p, Student& s)
{
cout << p._name << endl;
cout << s._name << endl;
cout << s._stuNum << endl;
}
void Test()
{
Person p;
Student s;
Display(p, s);
}8、继承与静态成员
基类定义了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; //研究科目
};
void Test()
{
Student s1;
Student s2;
Student s3;
Graduate s4;
cout << "人数" << Person::_count << endl;
Student::_count = 0;
cout << "人数:" << Person::_count << endl;
}
int main()
{
Test();
system("pause");
return 0;
}9、虚函数
（1）概念：类的成员函数前面加virtual关键字。
（2）虚函数重写：当在子类中定义了一个与父类完全相同的虚函数时，则称子类的这个函数重写了父类的这个虚函数。如图5所示：
图5 虚函数表示图
（3）总结：
1）派生类重写基类的虚函数实现多态，要求函数名、参数列表、返回值完全相同（协变除外）。
2）基类中定义了虚函数，在派生类中该函数始终保持虚函数的特性。
3）只有类的成员函数才能定义虚函数。
4）如果在类外定义虚函数，只能在声明函数是加virtual，在类外定义函数时不能加virtual。
5）静态成员函数不能定义虚函数。
6）构造函数不能为虚函数，虽然可以将operator=定义为虚函数，但是最好不要，因为容易在使用时混淆。
7）不要在构造函数和析构函数里调用虚函数，在构造函数和析构函数中，对象是不完整的，可能会发生未定义的行为。
8）最好把析构函数声明为虚函数。因为派生类的析构函数跟基类的析构函数名称不一样，但是构成覆盖。看图6：
【例】
//虚函数
class Person
{
public:
virtual void BuyTickets()
{
cout << "买票" << endl;
}
protected:
string _name; // 姓名
};
class Student : public Person
{
public:
virtual void BuyTickets()
{
cout << "买票-半价" << endl;
}
protected:
int _num;//学号
};
void Fun(Person& p)
{
p.BuyTickets();
}
void Test()
{
Person p;
Student s;
Fun(p);
Fun(s);
}
int main()
{
Test();
system("pause");
return 0;
}原创文章，作者：ItWorker，如若转载，请注明出处：https://blog.ytso.com/18208.html