C++继承和派生

继承和派生

继承机制： 是类型层次结构设计中实现代码的复用重要手段。
派生： 保持原有类特性的基础上进行扩展，增加新属性和新方法，从而产生新的类型。

在面向对象程序设计中，继承和派生是构造出新类型的过程。呈现类型设计的层次结构，体现了程
序设计人员对现实世界由简单到复杂的认识过程。

继承的概念与定义

C++ 通过类派生（ class derivation）的机制来支持继承。被继承的类称为基类（base class）或超
类（superclass），新产生的类为派生类（derived class）或子类（subclass）。基类和派生类的集合
称作类继承层次结构（hierarchy）。
由基类派生出，派生类的设计形式为：

class 派生类名：访问限定符 基类名
{
private:
成员表1; //派生类增加或替代的私有成员
public:
成员表2; //派生类增加或替代的公有成员
protected:
成员表3; //派生类增加或替代的保护成员
}；//分号不可少
1
2
3
4
5
6
7
8
9

示例:
定义一个person基类：

class Person
{
private:
char _idPerson[20]; //身份证号,18位数字
char _name[8]; //姓名
int _age;
public:
Person()
{
_idPerson[0] = '0';
_name[0] = '0';
_age = 1;
}
Person(const char* id, const char* name, int age)
{
strcpy_s(_idPerson, 20, id);
strcpy_s(_name, name);
_age = age;
}
~Person() {}
void Dance() const
{
cout<<" 跳舞"<<endl;
}
void PrintPersonInfo() const
{
cout << "身份证号: " << _idPerson << 't';
cout << "姓名: " << _name << "t";
cout << "年龄: " << _age << endl;
}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

定义一个学生派生类，public的形式继承person基类

// 派生类 访问限定符 基类
class Student : public Person
{
private:
char _snum[10];
float _score;
public:
void Study() const
{
cout<<"学生学习！"<<endl;
}
Student() :Person()
{
_snum[0] = '0';
_score = 0.0;
}
Student(const char * id,const char * name,int age,const char * num)
:Person(id,name,age)
{
strcpy_s(_snum,10,num);
_score = 0.0;
}
~Student() {}
void PrintStudentInfo() const
	{
	PrintPersonInfo();
	cout << "学号: " << _snum << "t" << "成绩: " << _score << endl;
	}
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

派生类sudent可以继承基类person的成员和方法

int main()
{
Student studx("61010100010102345", "yhping", 23, "2022001");
return 0;
}
1
2
3
4
5

派生类student可以调用基类person 的public和protected方法

**总结：**派生反映了事物之间的联系，事物的共性与个性之间的关系。派生与独立设计若干相关的类，前者工作量少，重复的部分可以从基类继承来，不需要单独编程。继承是类型设计层面上的复用。

编制派生类时可分四步

注意：

构造函数和析构函数不能被继承。 我们知道构造函数和析构函数是跟对象的创建与消亡的善后工
作相关。我们所创建派生类的对象，虽然和基类的对象有相同之处，但是仍然是不同的对象。所以，适用于基类的构造函数和析构函数不可能完全满足派生类对象的创建和消亡的善后工作。因此，构造函数和析构函数不被继承。

第二： 其他函数都可以通过类对象来调用，创建对象时由系统调用该对象所属类的构造函数，在
该对象生存期中也只调用这一次。由继承而来的派生类对象，是能够调用父类的函数，但不能调用构造函数也不能调用析构函数。
继承方式，亦称为访问控制，是对基类成员进一步的限制。继承方式也是三种：
公有（public）方式，亦称公有继承
保护（protected）方式，亦称保护继承
私有（private）方式， 亦称私有继承。

不同继承方式的区别

两层继承关系中的数据成员（可见性与访问控制）
如下代码，我们定义基类object和它的派生类Base

class Object
{
private: int oa;
protected: int ob;
public: int oc;
};
class Base : public Object
{
private: int bx;
protected: int by;
public: int bz;
};
int main()
{
Object obj;
Base base;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

二层继承关系中对象的存储结构和访问控制。

总结

1. 不论采取何种继承方式，基类中所有数据成员都将继承到派生类。
2. 在类型的继承层次结构中，保护属性当作公有属性来使用。
3. 继承性具有传递性。
4. 无论采取何种继承方式，派生类对象的成员方法都可以去访问基类对象中的保护和公有属性。
   基类对象与成员对象的区别。

多层继承关系中的数据成员（可见性与访问控制）

传递性
可以看如下代码，定义基类object和它的子类Base以及Base的子类Test

class Object
{
private: int oa;
protected: int ob;
public: int oc;
};
class Base : public Object
{
private: int bx;
protected: int by;
public: int bz;
};
class Test: public Base
{
private: int ta;
protected: int tb;
public: int tc;
};
int main()
{
Object obj;
Base base;
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

多层继承关系中对象的存储结构和访问控制。

C++ 对象模型

同名隐藏（成员属性）

如下代码示例：

 
class Object
{
public:
int value;
public:
Object(int x = 0) :value(x) {}
~Object() {}
void print(int x)
{
value = x;
cout << value << endl;
}
};
class Base : public Object
{
public:
int value;
public:
Base(int x = 0) : Object(x), value(x + 10) {}
~Base() {}
void print()
{
value += 10;
Object::value += 10;
}
};
int main()
{
Base base;
base.print();
//base.print(10); // error
base.Object::print(10);
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

如果派生类和基类都含有相同的成员value那么，当生成一个派生类对象的时候，调用value是基类的成员value将会被隐藏，除非声明是在基类的作用域下的value