C++学习笔记day16--继承

最新推荐文章于 2024-05-19 12:01:11 发布
最新推荐文章于 2024-05-19 12:01:11 发布
阅读量135 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41704516/article/details/107895373
版权

1、继承的基本语法

#include<iostream>
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 << "CPP学科视频" << endl;
	}
};

void test01()
{
	cout << "Java下载视频界面如下：" << endl;
	Java java;
	java.header();
	java.footer();
	java.left();
	java.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();
}
int main()
{
	test01();
	system("pause");
	return 0;
}

2、继承方式

#include<iostream>
using namespace std;

//继承实现页面
class Base1
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//公共继承
class Son1 :public Base1
{
public:
	void func()
	{
		m_A = 10;//父类中的公共权限成员 到子类中依然是公共权限
		m_B = 20;//父类中的保护权限成员 到子类中依然是保护权限
		//m_C = 30;//父类中的私有权限成员 子类访问不到
	}
};

void test01()
{
	Son1 s1;
	s1.m_A = 100;
	//s1.m_B = 200;//到Son1中，m_B是保护权限 类外访问不到
}
//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2 :protected Base2
{
public:
	void func()
	{
		m_A = 100;//父类中公共成员，到子类中变为保护权限
		m_B = 100;//父类中保护成员，到子类中变保护权限
		//m_C = 100;//父类中私有成员，子类访问不到
	}
};

void test02()
{
	Son2 s1;
	//s1.m_A = 1000;//在Son2中m_A变为保护权限，因此类外访问不到
	//s1.m_B = 1000;//在Son2中m_B保护权限，不可以访问
}

//私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3 :private Base3
{
public:
	void func()
	{
		m_A = 100;//父类中公共成员到子类中变为私有成员
		m_B = 100;//父类中保护成员到子类中变为私有成员
		//m_C = 100;//父类中私有成员，子类访问不到
	}
};
class GrandSon3 :public Son3
{
public:
	void func()
	{
		m_A = 1000;//到了Son3中m_A变为私有，即使是儿子，也访问不到
	}
};
void test03()
{
	Son3 s1;
	s1.m_A = 1000;//到Son3中变为私有成员，类外访问不到
	s1.m_B = 1000;//到Son3中变为私有成员，类外访问不到
}
int main()
{
	test01();
	system("pause");
	return 0;
}

3、继承中构造与析构顺序

#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;
	}
};
void test01()
{
	//继承中的构造和析构顺序如下：
	//先构造父类，再构造子类，析构顺序和构造的顺序相反
	Son s;
}
int main()
{
	test01();
	system("pause");
	return 0;
}

4、继承中同名成员处理方式

#include<iostream>
using namespace std;

//继承中同名成员处理
class Base
{
public:
	Base()
	{
		m_A = 100;
	}
	void func()
	{
		cout << "Base-func()调用"<<endl;
	}
	void func(int a)
	{
		cout << "Base-func()调用" << endl;
	}
	int m_A;
};
class Son :public Base
{
public:
	Son()
	{
		m_A = 200;
	}
	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);
}
int main()
{
	test02();
	system("pause");
	return 0;
}

5、继承同名静态成员处理方式

#include<iostream>
using namespace std;

//继承中的同名静态成员处理方式
class Base
{
public:
	static int m_A;
	static void func()
	{
		cout << "Base-static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base-static void func(int a)" << endl;
	}
};
int Base::m_A = 100;
class Son:public Base
{
public:
	static int m_A;
	static void func()
	{
		cout << "Son-static void func()" << endl;
	}

};
int Son::m_A = 200;

//同名静态成员属性
void test01()
{
	//1、通过对象访问
	cout << "通过对象访问：" << endl;
	Son s;
	cout << "Son 下m_A=" << s.m_A << endl;
	cout << "Base 下m_A=" << s.Base::m_A << endl;

	//2、通过类名访问
	cout << "通过类名访问：" << endl;
	cout << "Son下m_A=" << Son::m_A << endl;
	//第一个::代表通过类名方式访问 第二个::代表访问父类作用域下
	cout << "Base下m_A=" << Son::Base::m_A << endl;
}
//同名静态成员函数
void test02()
{
	//1、通过对象访问
	cout << "通过对象访问" << endl;
	Son s;
	s.func();
	s.Base::func();

	//2、通过类名访问
	cout << "通过类名访问" << endl;
	Son::func();
	Son::Base::func();

	//子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
	//如果想访问父类中被隐藏同名成员，需要加作用域
	Son::Base::func(100);

}
int main()
{
	test02();
	system("pause");
	return 0;
}

6、多继承语法

#include<iostream>
using namespace std;

//多继承语法

class Base1
{
public:
	Base1()
	{
		m_A = 100;
	}
	int m_A;
};
class Base2
{
public:
	Base2()
	{
		m_A = 100;
	}
	int m_A;
};

//子类 需要继承Base1和Base2

//语法：class 子类：继承方式 父类1，继承方式 父类2，....
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 Son = " << sizeof(s) << endl;
	//当父类中出现同名成员，需要加作用域区分
	cout << "Base1下m_A= " << s.Base1::m_A << endl;
	cout << "Base2下m_A= " << s.Base2::m_A << endl;

}
int main()
{
	test01();
	system("pause");
	return 0;

}

7、菱形继承

#include<iostream>
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 test01()
{
	SheepTuo st;
	st.Sheep::m_Age = 18;
	st.Tuo::m_Age = 28;
	//当菱形继承,有两个父类拥有相同数据，需要加以作用域区分
	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;
	//这份数据我们知道，只有一份就可以，菱形继承导致数据有两份，资源浪费
}
int main()
{
	test01();
	system("pause");
	return 0;

}
不将就w
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++学习笔记5--继承与派生
@轨轨的博客
03-11 353
继承与派生一级目录二级目录三级目录 一级目录 二级目录 三级目录
C++非常实用-学习-总结-笔记-.pdf
11-16
C++非常实用-学习-总结-笔记-.pdf
C++课堂学习(9)
weixin_43853077的博客
11-18 249
#include<iostream> using namespace std; class CBaseClass { protected: int a; int b; public: CBaseClass(); CBaseClass(int a1,int b1); virtual void Display(); } CBaseClass::CBaseClass():a(0),...
【C++学习笔记】虚基类（一）
热门推荐
小浣熊的博客
11-27 3万+
1.为什么要引入虚基类？ 在类的继承中，如果我们遇到这种情况： “B和C同时继承A，而B和C都被D继承” 在此时，假如A中有一个函数fun（）当然同时被B和C继承，而D按理说继承了B和C，同时也应该能调用fun()函数。这一调用就有问题了，到底是要调用B中的fun（）函数还是调用C中的fun（）函数呢？在C++中，有两种方法实现调用： (注意：这两种方法效果是不同的) 使用作用域标识符来唯一...
C++学习笔记 ---继承
星星leslie的博客
07-06 371
继承继承中的对象模型 继承中的对象模型 问题：从父类继承过来的成员，哪些属于子类对象中 //父类（基类） class Base { public: int m_A; protected: int m_B; private: int m_C; }; //子类（派生类） class Son: public Base { public: int m_D; }; void test01() { Son s1; cout << sizeof(s1) << endl; } 打印结果为
C++学习笔记day--17多态
qq_41704516的博客
08-12 167
1、多态的基本概念 #include<iostream> using namespace std; //多态 //动物类 class Animal { public: //虚函数 virtual void speak() { cout << "动物在说话" << endl; } }; //猫类 class Cat :public Animal { public: //重写 函数返回值类型 函数名 参数列表 完全相同 void speak() {
C++学习笔记day11-类与对象
qq_41704516的博客
07-20 161
1、封装的意义 #include<iostream> #include <string> using namespace std; //类的三大特性：封装，继承，多态 const double PI = 3.14; //设计一个类，求圆的周长 //圆求周长的公式：2*PI*半径 //class代表设计一个类，类后面紧跟着就是类名称 //访问权限有三种： /*/访问权限： 1.public 公共权限 成员在类内可以访问，类外也可以访问 2.protected 保护权限
C++学习笔记二--面向对象的概念
我叫柱子哥
02-21 991
记录下C++中面向对象的概念
《C++学习笔记---初阶篇1》---类与对象（上）
yl1509797225的博客
05-03 597
class ClassName{ // 类体：由成员函数和成员变量组成public：公有数据成员；公有成员函数；private:私有数据成员；私有成员函数；// 一定要注意后面的分号class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量;类中的函数称为类的方法或者 成员函数。1.声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。2.
C++学习笔记day46-----C++98-运算符重载、继承
displayMessage的博客
06-04 240
运算符重载、继承
C++非常实用-学习-总结-笔记.pdf
11-16
C++非常实用-学习-总结-笔记.pdf
C++学习笔记--函数
09-08
VS2013调试，可以直接运行。由几个例子组成，备份留作以后查看。
c++笔记9-引用.pdf
11-16
c++笔记9-引用.pdf
C++学习笔记- 面向对象 .md
11-13
C++学习笔记，博主个人向。内容是C++面对对象的，目录大致来源于菜鸟文档的C++面向对象，笔记是参考各种文章以及菜鸟文档改编的，内容包含C++类和对象（类定义和对象定义，类成员函数，类访问修饰符，友元函数，内联...
初识C语言——第二十一天
硬件菜鸟的成长之路
05-15 619
1.rand()函数是只能生成伪随机数，并且无返回值，使用前需调用srand()伪随机数生成器作为起点2.time（）函数是结构体函数，返回值是64为整数类型，可以通过time函数生成时间戳时间戳-函数调用的时间点和计算机的初始时间点之间的时间间隔3.void（）函数-无返回值类型函数4.while(1)-一直循环，直到break跳出。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 407
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 657
对于类类型，如果定义了接受。
手搓顺序表（C语言）
最新发布
m0_62646213的博客
05-19 818
顺序表头插头删，尾插尾删，任意位置插入删除的实现和优劣分析
c++--练习题---马会飞
09-11
马会飞这个问题是一个常见的练习题，通常用来考察面向对象的概念。在现实世界中，马并不能飞行，但我们可以使用面向对象的思维来解决这个问题。以下是一个可能的解答： ```python class Animal: def __init__(self, name): self.name = name class Horse(Animal): def __init__(self, name): super().__init__(name) def fly(self): print(f"{self.name}正在飞行！") horse = Horse("小黑") horse.fly() ``` 在这个例子中，我们定义了一个 Animal 类作为基类，它有一个 name 属性。然后，我们定义了一个 Horse 类继承自 Animal 类，并且添加了一个 fly 方法。尽管实际上马不能飞，但是我们给马添加了一个飞行的方法。 这个例子展示了面向对象编程的一种思路，即通过继承和方法重写来属性和行为的扩展。当然，这只是一个简单的例子，实际情况可能更加复杂。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值