5,411
社区成员




class 子类(派生类) : 继承方式 父类(基类)
#include<iostream>
using namespace std;
class Java {
public:
void header(){
cout << "首页、公开课、登录、注册...(公共头部信息)" << endl;
}
void footer(){
cout << "帮助中心、交流合作、站内地图...(公共底部信息)" << endl;
}
void left(){
cout << "Java、C++、C、Python...(公共分类列表)" << endl;
}
void content() {
cout << "Java 学科视频(页面内容)" << endl;
}
};
void test1()
{
cout << "Java 下载视频页面如下:" << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
}
int main(){test1();return 0;}
#include<iostream>
using namespace std;
class Java {
public:
void header(){
cout << "首页、公开课、登录、注册...(公共头部信息)" << endl;
}
void footer(){
cout << "帮助中心、交流合作、站内地图...(公共底部信息)" << endl;
}
void left(){
cout << "Java、C++、C、Python...(公共分类列表)" << endl;
}
void content() {
cout << "Java 学科视频(页面内容)" << endl;
}
};
class Python {
public:
void header() {
cout << "首页、公开课、登录、注册...(公共头部信息)" << endl;
}
void footer() {
cout << "帮助中心、交流合作、站内地图...(公共底部信息)" << endl;
}
void left() {
cout << "Java、C++、C、Python...(公共分类列表)" << endl;
}
void content() {
cout << "Python 学科视频(页面内容)" << endl;
}
};
class Cpp {
public:
void header() {
cout << "首页、公开课、登录、注册...(公共头部信息)" << endl;
}
void footer() {
cout << "帮助中心、交流合作、站内地图...(公共底部信息)" << endl;
}
void left() {
cout << "Java、C++、C、Python...(公共分类列表)" << endl;
}
void content() {
cout << "Python 学科视频(页面内容)" << endl;
}
};
void test1()
{
cout << "Java 下载视频页面如下:" << endl;
Java ja;
ja.header();
ja.footer();
ja.left();
ja.content();
cout << "-----------------------------------" << endl;
}
void test2() {
cout << "Python 下载视频页面如下:" << endl;
Python py;
py.header();
py.footer();
py.left();
py.content();
cout << "-----------------------------------" << endl;
}
void test3()
{
cout << "Cpp 下载视频页面如下:" << endl;
Cpp cpp;
cpp.header();
cpp.footer();
cpp.left();
cpp.content();
cout << "-----------------------------------" << endl;
}
int main(){test1();test2();test3();return 0;}
#include<iostream>
using namespace std;
class BasePage//公共部分
{
public:
void header(){
cout << "首页、公开课、登录、注册...(公共头部信息)" << endl;
}
void footer(){
cout << "帮助中心、交流合作、站内地图...(公共底部信息)" << endl;
}
void left(){
cout << "Java、C++、C、Python...(公共分类列表)" << endl;
}
};
//Java页面:Java 继承(:) BasePage的内容
class Java : public BasePage {
public:
void content() {
cout << "Java 学科视频" << endl;
}
};
//Pthyon页面:Pthyon 继承(:) BasePage
class Python : public BasePage {
public:
void content() {
cout << "Pthyon 学科视频" << endl;
}
};
//Cpp页面:Cpp 继承(:) BasePage
class Cpp : public BasePage {
public:
void content() {
cout << "C++ 学科视频" << endl;
}
};
void test() {
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();
cout << "-----------------------------------" << endl;
}
int main(){test();return 0;}
继承语法:class 派生类 : 继承方式 基类
#include<iostream>
using namespace std;
class Base {
public:
int m_A;
protected:
int m_B;
private:
int m_C;//父类中的私有成员,在子类被隐藏了,但仍可被子类继承
};
//公共继承
class Son1 : public Base {
public:
int m_D;
};
void test01() {
cout << "sizeof Son1 == " << sizeof(Son1) << endl;
}
int main(){test01();return 0;}
根据代码块的输出,我们可以验证:
父类中私有成员,在子类被隐藏了,但仍可被子类继承
结论:父类中所有非静态成员属性都会被子类继承下去
问题:父、子类间的构造和析构顺序先后顺序?
#include<iostream>
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;
}
};
int main(){ Son s;return 0; }
问题:当子类与父类出现同名的成员,如何通过子类对象,访问到子类或父类中同名的对象呢?
#include<iostream>
using namespace std;
class Base {
public:
Base() {
m_A = 100;
}
int m_A;
};
class Son : public Base {
public:
Son(){
m_A = 200;
}
int m_A;
};
void test() {
Son s;
cout << "Son 下的 s.m_A == " << s.m_A << endl;
cout << "Base 下的 s.m_A == " << s.Base::m_A << endl;
}
int main(){test();return 0;}
class Base {
public:
void func() {
cout << "Base - func 的调用!" << endl;
}
int m_A;
};
class Son : public Base {
public:
int m_A;
};
//当不存在 Son - func() 时,子类 Son 所实例化出 s,可以直接访问父类 Base 中的公共属性、行为
void test() { Son s; s.func(); }
#include<iostream>
using namespace std;
class Base {
public:
void func() {
cout << "Base - func 的调用!" << endl;
}
//函数重载:同一作用域下,函数的名称相同,但ha
void func(int) {
cout << "Son - func(int) 的调用!" << endl;
}
int m_A;
};
class Son : public Base {
public:
void func() {
cout << "Son - func 的调用!" << endl;
}
int m_A;
};
void test() {
Son s;
s.func();
s.Base::func();
s.Base::func(100);//函数重载
}
问题:继承中同名的静态成员在子类对象上如何进行访问?
#include<iostream>
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 test() {
//1.通过对象访问数据
cout << "通过对象访问:" << endl;
Son s;
cout << "Son - m_A == " << s.m_A << endl;
cout << "Base - m_A == " << Base::m_A << endl;
//2.通过类名访问数据
cout << "通过类名访问数据:" << endl;
cout << "Son - m_A == " << Son::m_A << endl;
//Son::(通过Son类名的访问方式) - Base::m_A(访问父类Base作用域下的m_A)
cout << "Base - m_A == " << Son::Base::m_A << endl;
}
int main(){test();return 0;}
#include<iostream>
using namespace std;
class Base {
public:
static void func() {
cout << "Base - static func()的调用!" << endl;
}
static void func(int) {
cout << "Base - static func(int)的调用!" << endl;
}
};
class Son : public Base {
public:
static void func() {
cout << "Son - static func()的调用!" << endl;
}
};
void test() {
//1.通过对象访问
cout << "通过对象访问:" << endl;
Son s;
s.func();
s.Base::func();
//2.通过类名访问
cout << "通过类名访问:" << endl;
Son::func();
Son::Base::func();
Son::Base::func(100);
}
int main(){test();return 0;}
class 子类 : 继承方式 父类1, 继承方式2 父类2
多继承可能会引发父类中有同名成员出现,需要加作用域区分
C++实际开发中不建议使用多继承
#include<iostream>
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 Son : public Base1, public Base2{
public:
Son()
{
m_C = 300;
m_D = 400;
}
int m_C;
int m_D;
};
void test(){
Son s;
cout << "sizeof(s) == " << sizeof(s) << endl;
}
int main(){test();return 0;}
#include<iostream>
using namespace std;
class Animal//动物类
{
public:
int m_Age;
};
class Sheep : public Animal//羊类
{
public:
};
class Tuo : public Animal//驼类
{
public:
};
class SheepTuo : public Sheep, public Tuo {
public:
};
void test() {
SheepTuo st;
st.m_Age = 100;
}
int main(){test();return 0;}
void test() {
SheepTuo st;
st.Sheep::m_Age = 100;
st.Tuo::m_Age = 200;
cout << "st.Sheep::m_Age == " << st.Sheep::m_Age << endl;
cout << "st.Tuo::m_Age == " << st.Tuo::m_Age << endl;
}
virtual ---> 变为虚继承,而其父类被称为虚基类
class Animal{
public:
int m_Age;
};
//class Sheep : virtual public Animal就是虚继承
class Sheep : virtual public Animal//此时Animal就被称为虚基类
{
public:
};
class Tuo : virtual public Animal{
public:
};
class SheepTuo : public Sheep, public Tuo {
public:
};
void test() {
SheepTuo st;
st.Sheep::m_Age = 100;
st.Tuo::m_Age = 200;
cout << "st.m_Age == " << st.m_Age << endl;
cout << "st.Sheep::m_Age == " << st.Sheep::m_Age << endl;
cout << "st.Tuo::m_Age == " << st.Tuo::m_Age << endl;
}
int main(){test();return 0;}
总结:
文章来源: https://blog.csdn.net/2401_87692970/article/details/146368244
版权声明: 本文为博主原创文章,遵循CC 4.0 BY-SA 知识共享协议,转载请附上原文出处链接和本声明。