类和对象 目录:
一、封装
二、对象的初始化和清理
三、C++对象模型和this指针
四、友元
五、运算符重载
六、继承
1. 继承的基本语法
继承的好处:减少重复代码
语法:class 子类: 继承方式 父类 {};
,其中子类也称为派生类,父类也称为基类,继承方式有公共继承、保护继承、私有继承三种。子类中的成员包含两大部分,一类是从父类继承过来的,一类是自己增加的成员;从父类继承过来的表现其共性,而新增的成员体现了其个性。
如果需要实现相同的网页头部、底部、左侧,中间的内容是不同的,那么普通实现是:
//普通实现页面
//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 << "---------------------" << 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();
}
使用继承方式的实现方法是:
//继承实现页面
//公共页面类
class BasePage
{
public:
void header()
{
cout << "首页、公开课、登录、注册...(公共头部)" << endl;
}
void footer()
{
cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
}
void left()
{
cout << "Java、Python、C++、...(公共分类列表)" << endl;
}
};
//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;
}
};
2. 继承方式
继承的语法:class 子类: 继承方式 父类 {};
继承方式一共有三种:
- 公共继承
public
- 保护继承
protected
- 私有继承
private
总结:
父类私有的属性,子类都不可以访问!
公共继承:父类中公共属性、被保护属性在子类中访问权限都不变。
保护继承:父类中公共权限、保护权限的内容在子类中均为保护权限。
私有继承:除了父类不可访问的私有权限内容,其它内容均为私有权限。
公共权限类内外均可访问;保护权限类内可以访问,类外不可以访问;私有权限类内外均不可访问。
3. 继承中的对象模型
class Base
{
public:
int m_A;
protected:
int m_B;
private:
int m_C;
};
class Son :public Base
{
public:
int m_D;
};
void test01()
{
cout << sizeof(Son) << endl;//16
}
最后的结果是16(m_A、m_B、m_C、m_D),也就是说父类中所有非静态成员属性都会被子类继承下去。父类中私有成员属性是被编译器隐藏了,因此访问不到,但确实被继承下去了。
也可以使用VisualStudio自带的工具查看对象模型:开发人员命令提示符Developer Command Prompt for VS 2019,然后跳转到当前代码所在的文件夹(先跳转盘符D:
,然后跳转文件路径cd xxx
),输入cl /d1 reportSingleClassLayoutSon "源.cpp"
,即可查看源.cpp(文件名)文件下Son(类名)类的布局,结果如下,可以清晰了解它所占的内存空间以及其父类:
4. 继承中构造和析构顺序
子类继承父类后,当创建子类对象,也会调用父类的构造函数。先构造父类,然后再构造子类;析构顺序与构造的顺序相反。(后进先出)
5. 继承同名成员处理方式
当子类和父类出现同名的成员时:
- 访问子类同名成员:直接访问即可
- 访问父类同名成员:需要加作用域
① 对于同名成员属性:
class Base
{
public:
Base()
{
m_A = 100;
}
int m_A;
};
class Son :public Base
{
public:
Son()
{
m_A = 200;
}
int m_A;
};
void test01()
{
Son s;
cout << "Son m_A = " << s.m_A << endl;//200
cout << "Base m_A = " << s.Base::m_A << endl;//100
//如果通过子类对象访问到父类中同名成员,需要加作用域
}
② 对于同名成员函数:
class Base
{
public:
void func()
{
cout << "Base - func()调用" << endl;
}
};
class Son :public Base
{
public:
void func()
{
cout << "Son - func()调用" << endl;
}
};
void test01()
{
Son s;
s.func();//Son - func()调用
s.Base::func();//Base - func()调用
}
如果子类中出现和父类同名的成员函数,子类的同名函数会隐藏掉父类中所有同名成员函数(包括发生函数重载的),无法通过子类对象直接访问。如果想访问到父类中被隐藏的同名成员函数,需要加作用域。
6. 继承同名静态成员处理方式
复习:
静态成员属性:所有对象都共享同一份数据,编译阶段就分配内存,类内声明,类内初始化
静态成员函数:只能访问静态成员属性,不能访问非静态成员变量
静态成员和非静态成员出现同名,处理方式一致:
- 访问子类同名成员:直接访问即可
- 访问父类同名成员:需要加作用域
① 同名静态成员属性:
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 test01()
{
//1、静态成员属性可以通过对象访问
cout << "通过对象访问" << endl;
Son s;
cout << "Son m_A = " << s.m_A << endl;//200
cout << "Base m_A = " << s.Base::m_A << endl;//100
//2、静态成员属性可以通过类名访问(因为大家共享同一份数据)
cout << "通过类名访问" << endl;
cout << "Son m_A = " << Son::m_A << endl;//200
cout << "Base m_A =" << Base::m_A << endl;//100,直接通过Base类访问
cout << "Base m_A =" << Son::Base::m_A << endl;//100,通过Son类去访问父类作用域下的属性
}
② 同名静态成员函数:
class Base
{
public:
static void func()
{
cout << "Base - static void func()" << endl;
}
};
class Son :public Base
{
public:
static void func()
{
cout << "Son - static void func()" << endl;
}
};
void test01()
{
//1、通过对象访问
cout << "通过对象访问" << endl;
Son s;
s.func();//Son - static void func()
s.Base::func();//Base - static void func()
//2、通过类名访问大家共享同一份数据)
cout << "通过类名访问" << endl;
Son::func();
Son::Base::func();
}
7. 多继承语法
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_C = 300;
m_D = 400;
}
int m_C;
int m_D;
};
void test01()
{
Son s;
cout << sizeof(s) << endl;//16
cout << s.Base1::m_A << endl;//100
cout << s.Base2::m_A << endl;//200
}
8. 菱形继承
菱形继承/钻石继承:两个派生类继承同一个基类,又有某个类同时继承这两个派生类。
菱形继承问题:如上图,羊继承了动物的数据,驼同样挤成了动物的数据,当羊驼使用数据时,就会产生二义性(在多继承那里讲过,可以通过加作用域解决二义性问题)。但羊驼继承动物的数据继承了两份,这份数据其实只需要一份就可以了(可利用虚继承解决)。
虚继承:在羊、驼继承之前,加上关键字virtual
,变为虚继承,此时动物类(最大的那个类)称为虚基类。
class Animal
{
public:
int m_Age;
};
class Sheep :virtual public Animal{};//虚继承
class Tuo : virtual public Animal{};//虚继承
class SheepTuo :public Sheep, public Tuo{};
void test01()
{
SheepTuo st;
//当菱形继承,两个父类拥有相同数据,可以加以作用域区分
st.Sheep::m_Age = 18;
st.Tuo::m_Age = 28;
cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;//28
cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;//28
cout << "st.m_Age = " << st.m_Age << endl;//28
//此时m_Age数据只有一份了!
}
【未完待续】