基本语法
减少重复代码
class BasePage {//公共页面
public:
void header() {
cout << "title,course,sign in,sign up...(public)" << endl;
}
void footer() {
cout << "help,talk,map...(public)" << endl;
}
void left() {
cout << "java,python,c++...(public)" << endl;
}
};
class Java :public BasePage {//class 子类:继承方式 父类
public://子类:也称为派生类 父类:也成为基类
void content() {
cout << "java video" << endl;
}
};//派生类中的成员,包含两大部分:一类是从基类继承过来的,一类是自己增加的成员
void test01() {//从基类继承过来的表现其共性,新增的成员表现其个性
cout << "java video download" << endl;
Java j;
j.header();
j.footer();
j.left();
j.content();
cout << "------------------" << endl;
}
继承方式
继承方式:公共继承,保护继承,私有继承
class Base1 {
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son1 :public Base1 {//公共继承
public:
void func() {
m_A = 1;//基类中的公共权限成员 到派生类中依然是公共权限
m_B = 1;//基类中的保护权限成员 到派生类中依然是保护权限
//m_C = 1;//基类中的私有权限成员 派生类不可访问
}
};
class Son2 :protected Base1 {//保护继承
public:
void func() {
m_A = 1;//基类中的公共权限成员 到派生类中变为保护权限
m_B = 1;//基类中的保护权限成员 到派生类中依然是保护权限
//m_C = 1;//基类中的私有权限成员 派生类不可访问
}
};
class Son3 :private Base1 {//私有继承
public:
void func() {
m_A = 1;//基类中的公共权限成员 到派生类中变为私有权限
m_B = 1;//基类中的保护权限成员 到派生类中变为私有权限
//m_C = 1;//基类中的私有权限成员 派生类不可访问
}
};
class GrandSon :public Son3 {//公共继承
public:
void func() {
//m_A = 100;//在Son3中m_A变为私有权限,即使是派生类,也无法访问
}
};
void test01() {
Son1 s1;
s1.m_A = 10;
//s2.m_B = 10;//在Son1中m_B变为保护权限,类外不可访问
Son2 s2;
//s2.m_A = 10;//在Son2中m_A变为保护权限,类外不可访问
Son3 s3;
//s3.m_A = 10;//在Son3中m_A变为私有权限,类外不可访问
}
继承中的对象模型
class Base {
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son :public Base {
public:
int m_D;
};//利用开发人员命令提示工具查看对象模型
//跳转根目录盘符 ex:D:+ ENTER;
//跳转文件路径 cd 根目录
//查看命名 cl /d1 reportSingleClassLayout类名 "文件名"
void test01() {
//基类中所有非静态成员属性都会被派生类继承下去
//基类中私有成员属性 是被编译器隐藏了,因此访问不到,但会被继承
cout << sizeof(Son) << endl;
}
继承中构造和析构顺序
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_A = 10;
}
void func() {
cout << "Base - func()调用" << endl;
}
void func(int a) {
cout << "Base - func(int a)调用" << endl;
}
int m_A;
};
class Son :public Base {
public:
Son() {
m_A = 9;
}
void func() {
cout << "Son - func()调用" << endl;
}
int m_A;
};
void test01() {//同名成员属性处理
Son s;
cout << "Son m_A = " << s.m_A << endl;
//通过派生类访问基类中同名成员,需要加作用域
cout << "Base m_A = " << s.Base::m_A << endl;
}
void test02() {//同名成员函数
Son s;
s.func();//直接调用,调用的是派生类中的成员变量
s.Base::func();//加作用域
//如果派生类中出现和基类同名的成员函数,派生类中的同名成员会隐藏掉基类中的所有同名成员函数
//s.func(100);
s.Base::func(100);//需要加作用域
}
继承同名静态成员处理方式
class Base {
public:
static int m_A;
static void func() {
cout << "Base static void fun()" << endl;
}
};
int Base::m_A = 100;
class Son :public Base {
public:
static int m_A;
static void func() {
cout << "Son static void fun()" << endl;
}
};
int Son::m_A = 10;
void test01() {//同名静态属性
Son s;
//通过对象访问数据
cout << "static Son m_A = " << s.m_A << endl;
cout << "static Base m_A = " << s.Base::m_A << endl;
//通过类名访问数据
cout << "static class Son m_A = " << Son::m_A << endl;
//第一个::表示通过类名方式访问,第二个::表示访问基类作用域下
cout << "static class Base m_A = " << Son::Base::m_A << endl;
}
void test02() {//同名静态函数
Son s;
//通过对象访问
s.func();
s.Base::func();
//通过类名访问
Son::func();//派生类出现和基类同名静态成员函数,会隐藏基类中所有同名成员函数
Son::Base::func();//如果想访问基类中被隐藏同名成员,需要加作用域
}
多继承语法(C++开发中不建议用多继承)
多继承可能会引发父类中有同名成员出现,需要加作用域区分
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 {//语法 class 派生类 : 继承方式 基类1, 继承方式 基类2...
public:
Son() {
m_C = 300;
m_D = 400;
}
int m_C;
int m_D;
};
void test01() {
Son s;
cout << sizeof(s) << endl;
//当基类中出现同名成员,需要加作用域区分
cout << "Base1 m_A = " << s.Base1::m_A << endl;
cout << "Base2 m_A = " << s.Base2::m_A << endl;
}
菱形继承(钻石继承)
两个派生类继承同一个基类,同时又有一个类同时继承两个派生类
菱形继承问题
vbptr:虚基类指针->vbtable:虚基类表格(记录偏移量)
v——virtual
b——base
ptr——pointer
class Animal {
public:
int m_Age;
};
//利用虚继承,解决菱形继承问题,需要在继承之前加上关键字virtual,称为虚基类
class Sheep :virtual public Animal {};
class Tuo :virtual public Animal {};
class SheepTuo :public Sheep, public Tuo {};
void test01() {
SheepTuo st;
st.Sheep::m_Age = 10;
st.Tuo::m_Age = 20;//当菱形继承,两个基类拥有相同数据,需要加以作用域区分
cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
//菱形继承导致数据有两份,资源浪费
cout << "st.m_Age = " << st.m_Age << endl;
}