C++ 类和对象-继承快速入门（超详细）
C++ 类和对象-继承
- 一、继承基本语法
-
- 1.先用普通方式实现页面
- 2.继承方式实现页面
- 二、继承方式
- 三、继承中的对象模型
- 四、继承中构造和析构的顺序
- 五、继承中同名的成员处理方式
- 六、继承同名静态成员处理
-
- 1 同名静态成员
- 2 同名静态成员
- 七、多继承语法
-
- 1 基本语法
- 2 调用
- 八、菱形继承
-
- 1.基本语法
- 2 解决菱形继承资源浪费问题
一、继承基本语法
继承是面向对象三大特性之一 （封装、继承、多态）
有些类与类之间存在特殊的关系，例如下图中:
我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。
这个时候我们就可以考虑利用继承的技术，减少重复代码
以黑马程序员官网为例，可以看到：
网页的头部、左侧、底部内容都是一样的公共信息，只有中的内容不一样
我们要想描述页面内容，可以用继承思想
1.先用普通方式实现页面
#include
using namespace std;
//普通实现
class Java
{
public:
void header()
{
cout << "首页、公共课、登录、注册，，，，（公共头部）"< 
2.继承方式实现页面
//继承好处：减少重复发代码
//语法：class 子类：继承方式 父类
//子类 也称为 派生类
//父类 也称为 基类
#include
using namespace std;
//继承实现页面
//公共页面类
class BasePage
{
public:
void header()
{
cout << "首页、公共课、登录、注册，，，，（公共头部）" << endl;
}
void footer()
{
cout << "交流中心、合作，，，，，（公共底部）" << endl;
}
void left()
{
cout << "java、python、c++，，，（公共分类）" << endl;
}
};
//继承好处：减少重复发代码
//语法：class 子类：继承方式 父类
//子类 也称为 派生类
//父类 也称为 基类
//Java页面
class Java:public 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 test0()
{
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 cp;
cp.header();
cp.footer();
cp.left();
cp.content();
}
int main()
{
test0();
system("pause");
return 0;
}
总结：
派生类中的成员，包含两大部分:
一类是从基类继承过来的，一类是自己增加的成员。
从基类继承过来的表现其共性，而新增的成员体现了其个性
二、继承方式
继承的语法:class子类∶继承方式父类
继承方式一共有三种:
·公共继承
·保护继承
·私有继承
#include
using namespace std;
//公共继承
class BASE1
{
public:
int a;
protected:
int b;
private:
int c;
};
class Son1 :public BASE1
{
public:
void fun()//a,b在子类中可以访问，继承得到了访问权限//换言之，类内可以访问
{
a = 10; //父类中的公共权限成员 到子类中依然是公共权限
b = 10; //父类中的保护权限成员 到子类中依然是保护权限
//c = 10;//父类中的私有权限成员 子类访问不到
}
};
void test1() //公共权限类外可以访问，保护权限和私有权限，类外不可访问
{
Son1 s1;//Son1继承的是公共权限，所以类外还可以访问到公共成员a
s1.a = 100;
//s1.b = 100;//到Son1中 b是保护类型 访问不到
}
//保护继承
class BASE2
{
public:
int a;
protected:
int b;
private:
int c;
};
class Son2 :protected BASE2
{
public:
void fun()
{
a = 10;
b = 10;
//c = 10;//父类中的私有权限成员 子类访问不到
}
};
void test2()
{
Son2 s2;
//s2.a = 100;//在Son2中a变成了保护权限 因此类外访问不到
//s2.b = 100;//在Son2中b保护权限 不可以访问
//s2.c = 100;
}
class BASE3
{
public:
int a;
protected:
int b;
private:
int c;
};
//私有继承
class Son3 :private BASE3
{
public:
void fun()
{
a = 10;//父类中公共成员 到子类中变为私有成员
b = 10;//父类中保护成员 到子类中变为私有成员
//c = 10;
}
};
void test3()
{
Son3 s3;
//s3.a = 100;
//s3.b = 100;
//s3.c = 100;
}
孙子GrandSon3访问不到父类Son3的私有成员
class GrandSon3 : public Son3
{
public: //Son3中的成员都是私有成员，孙子GrandSon3访问不到父类Son3的私有成员
void func()
{
//a = 100;//到了Son3中，a变为私有，即使是儿子也访问不到
//b = 100;
}
};
三、继承中的对象模型
#include
using namespace std;
//继承中的对象模型
class BASE
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son :public BASE
{
public:
int m_D;
};
void test()
{
//16 (父类中3个+自己1个)
//父类中所有非静态成员属性 都会被继承下去,
//父类中的私有成员属性，被编译隐藏了，但确实被继承下来
cout << "size of Son=" << sizeof(Son) << endl;
}
int main()
{
test();
return 0;
}
//验证
//利用开发人员命令提示工具查看对象模型
//跳转盘符
//跳转盘符路径 cd 具体路径下
//查看命令
//cl /d1 reportSingleClassLayout类名 文件名
查看
//利用开发人员命令提示工具查看对象模型
结果如下
实现步骤
//利用开发人员命令提示工具查看对象模型
//跳转盘符
//跳转盘符路径 cd 具体路径下
//查看命令
//cl /d1 reportSingleClassLayout类名 文件名
图文详解：
//打开开发人员命令提示符工具
//跳转盘符
输入.cpp文件所在盘符 G:
复制.cpp文件路径
跳转盘符路径 cd 具体路径下
输入dir
//查看命令
//cl /d1 reportSingleClassLayout类名 .cpp文件序号或名字，按下tab键,按下回车
注意c后面是小写的L，d后面的数字1
//cl /d1 reportSingleClassLayoutSon ab
完整的
四、继承中构造和析构的顺序
继承中先调用父类构造函数，在调用子类构造函数，析构是相反的
//继承的顺序：先构造父类，在构造子类（先有爸爸，再有儿子）
//析构的顺序与继承相反
#include
using namespace std;
//继承中构造和析构顺序
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 test()
{
//继承的顺序：先构造父类，在构造子类
//析构的顺序与继承相反
Son s;
}
int main()
{
test();
return 0;
}
五、继承中同名的成员处理方式
#include
using namespace std;
//继承中同名成员处理方式
class BASE
{
public:
BASE()
{
m = 100;
}
int m;
};
class Son :public BASE
{
public:
Son()
{
m = 200;
}
int m;
};
void test()
{ // 同名调用
Son s;
cout << "Son下 m=" << s.m << endl;
//通过子类对象访问 父类中同名成员，需加作用域
cout << "BASE下 m=" << s.BASE::m << endl;
}
int main()
{
test();
return 0;
}
#include
using namespace std;
//继承中同名成员处理方式
class BASE
{
public:
BASE()
{
m = 100;
}
void fun()
{
cout << "BASE下的 fun()" << '\n' << endl;
}
void fun(int a)
{
cout << "BASE下的 fun(int a)" << '\n' << endl;
}
int m;
};
class Son :public BASE
{
public:
Son()
{
m = 200;
}
void fun()
{
cout << "Son下的 fun()" << '\n' << endl;
}
int m;
};
void test()
{ // 同名调用
Son s;
cout << "Son下 m=" << s.m << '\n' << endl;
//通过子类对象访问 父类中同名成员，需加作用域
cout << "BASE下 m=" << s.BASE::m << '\n' << endl;
s.fun(); // 子类函数 直接调用成员名
s.BASE::fun();//父类函数同名成员调用，需加作用域
//如果子类中出现和父类同名的成员函数，子类中的同名函数会隐藏掉父类中所有的同名函数
//如果想访问到父类中被隐藏的，需要加作用域
//s.fun(100); 直接引用访问父类中的 fun(int a)函数报错，应为父类中的fun()、fun(int a)都被隐藏了
s.BASE::fun(100);//父类函数同名成员调用，需加作用域
}
int main()
{
test();
return 0;
}
总结:
1.子类对象可以直接访问到子类中同名成员
2.子类对象加作用域可以访问到父类同名成员
3.当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数
六、继承同名静态成员处理
1 同名静态成员
//1.通过对象访问
//2.通过类名访问
#include
using namespace std;
//继承中同名静态成员处理方式
class Base
{
public:
static int m_A;
};
int Base::m_A = 100;
class Son :public Base
{
public:
static int m_A;
};
int Son::m_A = 200;
//同名静态成员属性
void test1()
{
//1.通过对象访问
cout << "通过对象访问：" << endl;
Son s;
cout << "Son 下m_A=" << s.m_A << endl;
cout << "Base下m_A=" << s.Base::m_A << endl << endl;
//2.通过类名访问
cout << "通过类名访问：" << endl;
cout << "Son 下m_A=" << Son::m_A << endl;
cout << "Base下m_A=" << Base::m_A << endl;
//第一个::代表通过类名方式访问
//第二个::代表访问父类作用域下
cout << "Base下m_A=" << Son::Base::m_A << endl;
}
int main()
{
test1();
return 0;
}
2 同名静态成员
//1.通过对象访问
//2.通过类名访问
#include
using namespace std;
//继承中同名静态成员处理方式
class Base
{
public:
static void funct()
{
cout << "Base static void func()调用"< 
//子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
//如果想访问父类中被隐藏同名成员，需要加作用域
#include
using namespace std;
//继承中同名静态成员处理方式
class Base
{
public:
static void funct()
{
cout << "Base static void func()调用"< 
七、多继承语法
1 基本语法
#include
using namespace std;
//多继承
class Base1
{
public:
Base1()
{
m_A = 100;
}
int m_A;
};
class Base2
{
public:
Base2()
{
m_B = 200;
}
int m_B;
};
//子类 需要继承Base1和Base2
//语法：class 子类：继承方式 父类1，继承方式 父类2 ...
class Son : public Base1, public Base2
{
public:
Son()
{
m_C = 300;
m_D = 400;
}
int m_C,m_D;
};
void test1()
{
Son s;
cout << "sizeof Son = " < 
G:
cd G:\Program\C++\C++
dir
cl /d1 reportSingleClassLayoutSon “ab.cpp”
(CL 小写 ， D小写，数字1)
2 调用
#include
using namespace std;
//多继承
class Base1
{
public:
Base1()
{
m_A = 100;
}
int m_A;
};
class Base2
{
public:
Base2()
{
m_B = 200;
}
int m_B;
int m_A=500;
};
//子类 需要继承Base1和Base2
//语法：class 子类：继承方式 父类1，继承方式 父类2 ...
class Son : public Base1, public Base2
{
public:
Son()
{
m_C = 300;
m_D = 400;
}
int m_C,m_D;
};
void test1()
{
Son s;
cout << "sizeof Son = " <
八、菱形继承
1.基本语法
#include
using namespace std;
//动物类
class Animal
{
public:
int m_Age;
};
//羊类
class Sheep:public Animal {};
//驼类
class Tuo:public Animal{};
class SheepTuo : public Sheep, public Tuo{};
void test1()
{
SheepTuo st;
st.Sheep::m_Age = 18;
st.Tuo::m_Age = 28;
//当菱形继承，两个父类拥有相同数据，需要加一作用域区分
//cout << "m_Age=" << st.m_Age << endl;//二义性
cout << "Sheep m_Age=" << st.Sheep::m_Age << endl;
cout << "Tuo m_Age=" << st.Tuo::m_Age << endl;
//羊驼两个年龄，那么羊驼到底多少岁？
//这份数据我们知道只有有一份就可以，菱形继承导致数据有两份，资源浪费
}
int main()
{
test1();
return 0;
}
//羊驼两个年龄，那么羊驼到底多少岁？
//这份数据我们知道只有有一份就可以，菱形继承导致数据有两份，资源浪费
2 解决菱形继承资源浪费问题
//羊驼两个年龄，那么羊驼到底多少岁？
//这份数据我们知道只有有一份就可以，菱形继承导致数据有两份，资源浪费
//利用虚继承解决菱形继承的问题
//继承之前加上关键字virtual变为虚继承
//Animal类称为虚基类
//羊类
class Sheep:virtual public Animal {};
//驼类
class Tuo:virtual public Animal{};
完整程序
#include
using namespace std;
//动物类
class Animal
{
public:
int m_Age;
};
//利用虚继承解决菱形继承的问题
//继承之前加上关键字virtual变为虚继承
//Animal类称为虚基类
//羊类
class Sheep:virtual public Animal {};
//驼类
class Tuo:virtual public Animal{};
class SheepTuo : public Sheep, public Tuo{};
void test1()
{
SheepTuo st;
st.Sheep::m_Age = 18;
st.Tuo::m_Age = 28;
//当菱形继承，两个父类拥有相同数据，需要加一作用域区分
cout << "Sheep m_Age=" << st.Sheep::m_Age << endl;
cout << "Tuo m_Age=" << st.Tuo::m_Age << endl;
cout << "m_Age=" << st.m_Age << endl;//虚继承，此时这种访问不在二义性
}
int main()
{
test1();
return 0;
}
