1.继承的概念及定义
1.1继承的概念
继承机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。
1.2继承的定义格式
1.3继承基类成员访问方式的变化
（1）公有继承
基类的公有成员，子类可以继承为自己的公有成员。在派生类可以访问，在外部也可以访问。
基类的保护成员，子类可以继承为自己的保护成员，在派生类可以访问，在外部不可以访问。
基类的私有成员，子类不可以访问基类的私有成员。
（2）保护继承
基类公有成员，子类中继承为自己的保护成员，在派生类可以访问，在外部不可以访问。
基类保护成员，子类中继承为自己的保护成员，在派生类可以访问，在外部不可以访问。
基类私有成员，子类不可以访问基类的私有成员。
（3）私有继承
基类公有成员，子类中继承为自己的私有成员，在派生类可以访问，在外部不可以访问。
基类保护成员，子类中继承为自己的私有成员，在派生类可以访问，在外部不可以访问。
基类私有成员，子类不可以访问基类的私有成员。
1.4总结
(1)基类private成员任何方式继承在派生类中都是不可见的。不可见指派生类对象不能去访问它，但是基类的私有成员还是被继承到了派生类对象中。
(2)基类的public成员和protected成员任何继承方式在派生类都可以访问。
(3)基类pretected成员，派生类可以访问，类外不能访问。
(4)基类的其他成员在子类的访问方式 == Min（成员在基类的访问限定符，继承方式）。public > protected > private。
(5)使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。
|
1
2
3 |
class Derived : public Base //指明继承方式是public
class Derived : Base //没写的情况下是private
struct Derived : Base //没写的情况下是public
|
(6)在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，实际中
扩展维护性不强。
2.基类和派生类对象赋值转换
派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。
基类对象不能赋值给派生类对象
基类的指针可以通过强制类型转换赋值给派生类的指针。但是必须是基类的指针是指向派生类对象时才是安全的。
|
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 |
class Person //基类/父类
{
protected :
string _name; // 姓名
string _sex; // 性别
int _age; // 年龄
};
class Student : public Person //派生类/子类
{
public :
int _No ; // 学号
};
void Test ()
{
Student sobj ; //创建子类对象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;
}
|
3.继承中的作用域
在继承体系中基类和派生类都有独立的作用域。
子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
注意在实际中在继承体系里面最好不要定义同名的成员。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24 |
// 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
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59 |
//如果通过子类对象调用相同名称的成员时，优先访问子类的，基类同名的成员永远无法通过
// 子类对象直接调用到，相当于子类同名成员将基类的同名成员隐藏了
// 如果想要同名子类对象访问基类中同名的成员，只需在成员前加上基类名称::
// 如果在子类成员函数中，想要访问基类同名的成员，只需在基类成员前加上基类名称::
class Base //基类
{
public:
void SetBase(int b)
{
_b = b;
}
void fun()
{
cout << "Base::fun()" << endl;
}
public:
int _b;
char _c;
};
class Derived : public Base //派生类
{
public:
void SetDeirved(int b, int d)
{
_c = 100;
Base::_c = 100; //如果在子类成员函数中，想要访问基类同名的成员，只需在基类成员前加上基类名称::
__super::_c = 100;
SetBase(b);
_d = d;
}
void fun(int a)
{
cout << "Derived::fun(int)" << endl;
}
public:
int _d;
int _c;
};
int main()
{
Base b;
b.SetBase(10);
Derived d;
d.SetDeirved(100, 200);
/*
如果子类和基类中具有相同名称的成员变量时，不管成员变量的类型是否相同，
都优先访问子类的同名成员变量
不能通过子类对象直接访问子类和父类中同名的成员变量，就相当与子类同名的成员变量将基类的同名成员变量隐藏了
*/
d._c = 'A'; // d对象中有两个_c
// 有些情况下可能需要通过子类对象访问基类中同名的成员变量
d.Base::_c = 'B';
// d.fun(); // 编译报错
d.fun(10);
d.Base::fun(); //如果想要同名子类对象访问基类中同名的成员，只需在成员前加上基类名称::
return 0;
}
|
总结
本篇文章就到这里了，希望能给你带来帮助
7
0
已为社区贡献56条内容
所有评论(0)