Day 13 C++面向对象编程 之 继承
·
Day 13 C++面向对象编程 之 继承
一、基本语法
继承是面向对象的三大特性之一。有些类与类之间存在一些特殊关系：
可以看出，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。这个时候就可以考虑利用技术，来减少重复代码。
在网站中，很多页面都有公共的头部（导航栏）、公共的底部以及公共的左侧列表（导航栏），只有中心的内容不同。下面给出利用普通写法（每个都自己写）和继承写法来实现网页中心的内容，探讨继承的好处。
1. 普通写法：
//java页面
class Java
{
public:
void header()
{
cout << "首页、公开课、登录、注册...公共头部" << endl;
}
void footer()
{
cout << "帮助、交流、站内地图...公共底部" << endl;
}
void left()
{
cout << "java、python、C++...公共服务列表" << endl;
}
void content()
{
cout << "java学科视频" << endl;
}
};
//python页面
class Python
{
public:
void header()
{
cout << "首页、公开课、登录、注册...公共头部" << endl;
}
void footer()
{
cout << "帮助、交流、站内地图...公共底部" << endl;
}
void left()
{
cout << "java、python、C++...公共服务列表" << endl;
}
void content()
{
cout << "python学科视频" << endl;
}
};
//C++页面
class CPP
{
public:
void header()
{
cout << "首页、公开课、登录、注册...公共头部" << endl;
}
void footer()
{
cout << "帮助、交流、站内地图...公共底部" << endl;
}
void left()
{
cout << "java、python、C++...公共服务列表" << endl;
}
void content()
{
cout << "C++学科视频" << endl;
}
};
void test01()
{
cout << "java下载视频页面如下：" << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
cout << "python下载视频页面如下：" << endl;
Python py;
py.header();
py.footer();
py.left();
py.content();
cout << "C++下载视频页面如下：" << endl;
CPP cpp;
cpp.header();
cpp.footer();
cpp.left();
cpp.content();
}
2. 继承写法：
class BasePage//存放公共内容
{
public:
void header()
{
cout << "首页、公开课、登录、注册...公共头部" << endl;
}
void footer()
{
cout << "帮助、交流、站内地图...公共底部" << endl;
}
void left()
{
cout << "java、python、C++...公共服务列表" << endl;
}
};
//JAVA页面
class Java:public BasePage//加冒号表示继承BasePage里面的内容，然后在下面再写自己单独的增加的内容
{
public:
void content()
{
cout << "java学科视频" << endl;
}
};
//Python页面
class Python :public BasePage
{
public:
void content()
{
cout << "python学科视频" << endl;
}
};
//C++页面
class CPP :public BasePage
{
public:
void content()
{
cout << "C++学科视频" << endl;
}
};
void test01()
{
cout << "java下载视频页面如下：" << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
cout << "---------" << endl;
cout << "python下载视频页面如下：" << endl;
Python py;
py.header();
py.footer();
py.left();
py.content();
cout << "---------" << endl;
cout << "C++下载视频页面如下：" << endl;
CPP cpp;
cpp.header();
cpp.footer();
cpp.left();
cpp.content();
}
继承的好处：减少重复代码
3. 继承的语法：
class 子类名：继承方式 父类名
子类也称为派生类，父类也称为基类。子类中的成员，包含父类的成员以及自己增加的成员，从基类继承过来的是共性，自己新增的是个性
二、继承方式
继承方式共三种：
- 公共继承 public
- 保护继承 protected
- 私有继承 private
//1.公共继承pubic
class Base1
{
public:
int a;
protected:
int b;
private:
int c;
};
class Son1 :public Base1
{
public:
void func()
{
a = 7;//无报错，父类的公共权限，在子类中仍是公共权限，能访问
b = 7;//无报错，父类的保护权限内容，在子类中仍是保护权限，能访问
//c = 7;//报错，父类的私有权限成员，子类不可访问，
}
};
void test01()
{
Son1 s1;
s1.a = 100;//无报错，共有权限的内容，类外也可以访问
//s1.b = 100;//报错，保护权限的内容，（类外）外部函数不可访问
}
//2.保护继承
class Base2
{
public:
int a;
protected:
int b;
private:
int c;
};
class Son2 :protected Base2
{
public:
void func()
{
a = 7;//可以访问,父类中公有权限内容，在子类中变为保护权限内容
b = 6;//可以访问父类中保护权限内容，在子类中变为保护权限内容
//c = 8;//报错，父类私有权限内容，子类不可以访问
}
};
void test02()
{
Son2 s2;
//s2.a = 7;//报错
//s2.b = 8;//报错
//s2.c = 9;//报错
//是保护权限继承，类外不可访问
}
//3.私有继承
class Base3
{
public:
int a;
protected:
int b;
private:
int c;
};
class Son3 :private Base3
{
public:
void func()
{
a = 7;//父类的公有权限可以访问，但是在子类中变成私有成员，类内可以访问
b = 7;//父类的保护权限可以访问，但是在子类中变成私有成员，类内可以访问
//c = 7;//报错，父类的私有属性，子类不可以访问
}
};
void test03()
{
Son3 s3;
//均报错，因为在子类中为自由成员，所以，类外不可访问
//s3.a = 8;
//s3.b = 8;
//s3.c = 8;
}
class GrandSon3 :public Son3
{
public:
void func()
{
//a = 9;//在Son3中，这些都变成私有的了，所以在儿子中不可以访问
//b = 9;
}
};
- 父类私有的成员属性，子类不管怎么继承都不可能访问；
- 子类公有继承：父类的公有成员属性在子类中仍是公有成员属性，父类的保护类成员属性在子类中仍是保护权限成员属性
- 子类保护继承：父类的公有成员属性和保护类成员属性在子类中都是保护权限成员属性
- 子类私有继承：父类的公有成员属性和保护类成员属性在子类中都是私有权限成员属性
三、继承中的对象模型
从父类中继承过来的成员，哪些属于子类对象中？父类的所有的属性（非静态的成员属性）都会被子类继承下去，只是看能不能访问得到。
class Base
{
public:
int a;
protected:
int b;
private:
int c;//虽然是私有，但还是会被继承
};
class Son :public Base
{
public:
int d;
};
void test01()
{
cout << "size of Son=" << sizeof(Son) << endl;//16,有4个int成员，4x4=16
}
四、构造和析构顺序
子类继承父类后，当创建子类对象，也会调用父类的构造函数。但是子类和父类的构造和析构函数谁先谁后？
class Base
{
public:
Base()
{
cout << "Base父类的构造函数" << endl;
}
~Base()
{
cout << "Base父类的析构函数" << endl;
}
};
class Son :public Base
{
public:
Son()
{
cout << "子类Son的构造函数" << endl;
}
~Son()
{
cout << "子类Son的析构函数" << endl;
}
};
void test01()
{
Son s;
}
先构造父类，再构造子类：先有父类的构造函数，再有子类的构造；
先析构子类，再析构父类：子类的析构，最后再是父类的析构。
五、同名成员处理方式
当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据？
- 访问子类同名成员 直接访问即可
- 访问父类同名成员 需要加作用域 父类名::
class Base
{
public:
Base()
{
m = 7;
}
void func()
{
cout << "父类Base的函数" << endl;
}
int m;
};
class Son :public Base
{
public:
Son()
{
m = 8;
}
void func()
{
cout << "子类Son的函数" << endl;
}
int m;
};
//同名的成员属性
void test01()
{
Son s;
cout << "m = " << s.m << endl;//直接访问的是子类的（自身的）
cout << "m = " << s.Base::m << endl;//增加父类的作用域，告知访问的父类的作用域
}
//同名的成员函数
void test02()
{
Son s;
cout << "m = " << s.m << endl;//直接访问的是子类的（自身的）
cout << "m = " << s.Base::m << endl;//增加父类的作用域，告知访问的父类的作用域
}
父类与子类有相同名字的成员时，直接访问的是子类（自身）的，若要访问父类的成员，一定得加作用域，告诉编译器访问的是父类的那个成员，而不是子类的成员
cout << "m = " << s.m << endl;//直接访问的是子类的（自身的）
cout << "m = " << s.Base::m << endl;//增加父类的作用域，告知访问的父类的作用域
cout << "m = " << s.m << endl;//直接访问的是子类的（自身的）
cout << "m = " << s.Base::m << endl;//增加父类的作用域，告知访问的父类的作用域
只要子类中出现和父类同名的成员函数，子类的同名成员函数会隐藏掉父类中所有同名成员函数（包括函数的重载），苏哦需要访问到父类的成员函数，就要加作用域来实现访问父类中的成员函数
六、继承同名静态成员处理方式
继承中同名的静态成员在子类对象上如何进行访问？静态成员和非静态成员出现同名，处理方式一致：
- 访问子类同名成员 直接访问即可
- 访问父类同名成员 需要加作用域
class Base
{
public:
static int a;//静态成员，类内声明，内外初始化
static void func()
{
cout << "Base的静态函数" << endl;
}
};
int Base::a = 100;
class Son :public Base
{
public:
static int a;
static void func()
{
cout << "Son的静态函数" << endl;
}
};
int Son::a = 200;
//同名静态属性
void test01()
{
//1.通过对象访问静态成员属性
Son s;
cout << "a = " << s.a << endl;//直接访问，访问的是子类的
cout << "a = " << s.Base::a << endl;//加作用域，访问父类
//2.通过类名访问静态成员属性
cout << "通过类名进行访问" << endl;
cout << "a = " << Son::a << endl;//直接访问，访问到的是子类的
cout << "a = " << Son::Base::a << endl;//加作用域，访问父类的，第一个代表通过类名访问，第二个：：表示通过子类加作用域访问父类的成员
}
void test02()
{
//1.通过对象访问
Son s;
s.func();
s.Base::func();
//2.通过类名访问
Son::func();
Son::Base::func();
}
静态成员访问有两种方式：
- 通过对象访问
- 通过类名访问
若子类出现和父类同名的静态成员函数，会隐藏父类所有的同名成员函数，若想要访问，就要加作用域
七、多继承语法
c++允许一个类继承多个类，语法：
class 子类名：继承方式 父类名1，继承方式 父类名2...
多继承可能会引发父类中有同名成员出现，需要加作用域用以区分
class Base1
{
public:
Base1()
{
m_a = 100;
}
int m_a;
};
class Base2
{
public:
Base2()
{
m_a = 200;
}
int m_a;
};
class Son :public Base1, public Base2//多继承
{
public:
Son()
{
m_a = 300;
m_d = 400;
}
int m_a;
int m_d;
};
void test01()
{
Son s;
cout << "sizeof Son = " << sizeof(Son) << endl;//4 x 4 = 16
cout << "Base1中的m_a = " << s.Base1::m_a << endl;//100
cout << "Base2中的m_a = " << s.Base2::m_a << endl;//200
cout << "Son中的m_a = " << s.m_a << endl;//300
}
c++实际开发中不建议用多继承
八、菱形继承
概念：两个派生类继承同一个基类，又有某个类同时继承这两个派生类。这种继承被称为菱形继承或者钻石继承。
菱形继承的典型案例：动物可以分为驼、羊，然后羊驼又有羊的特点，又有驼的特点，所以羊驼继承二者，构成菱形继承。
典型问题：
1.羊继承了动物的数据，驼继承了动物的数据，羊驼使用数据时，会产生二义性；
2.羊驼继承动物的数据继承了两份，但是对于某些数据，我们应该只需要一份即可
这里，当两个父类拥有相同的成员属性数据时，需要加作用域进行区分；其次，这份数据，我们其实只需要一份，但是这里有两份，所以就造成了资源浪费。利用虚继承可以解决菱形继承的资源浪费问题。在继承之前加上关键字 virtual 变成虚继承
class Animal
{
public:
int m_Age;
};
class Sheep : virtual public Animal //Animal为虚基类
{
};
class Tuo : virtual public Animal //Animal为虚基类
{
};
class SheepTuo :public Sheep, public Tuo
{
};
void test01()
{
SheepTuo st;
//st.m_Age = 18;//不明确，因为继承了两份，但是只需要一份
st.Sheep::m_Age = 18;
st.Tuo::m_Age = 17;
//当菱形继承时，有两个父类拥有相同的属性数据时，需要加以作用域进行区分
cout << "羊里面的年龄：" << st.Sheep::m_Age << endl;//17，虚继承之前为18
cout << "驼里面的年龄：" << st.Tuo::m_Age << endl;//17，虚继承之前为17
cout << "驼里面的年龄：" << st.m_Age << endl;//17
//但是这份数据只需要一份即可，菱形继承导致了数据有两份，造成资源浪费
}
虚继承最大的父类（最开始的父类）叫虚基类，虚继承之后，数据就只有一个了，类似于共享数据，采用最后一次修改的数据为最终数据
tips：
ctrl+k+c等于选中多行同时注释；ctrl+k+u选中多行解开注释
vbptr，虚基类指针，指向虚基类表vbtable，表中记录了偏移量
查看对象格式：(由哪些成员组成)
Visual Studio 20xx的开发人员命令提示符----进入当前文件对应的盘符—进入当前文件对劲的文件夹（cd 路径）----dir（查看当前路径是否存在这个文件）----cl /d1 reportSingalClassLayout类名 “类所在文件名.cpp”
cl /d1 reportSingalClassLayout类名 "类所在文件名.cpp"
Sheep的虚基类指针，可以看出偏移量为8，指针走了偏移量就找到了唯一的数据，从此解决菱形继承两份数据的问题
Agent 垂直技术社区，欢迎活跃、内容共建。
更多推荐
24
0- 0
已为社区贡献18条内容
所有评论(0)