类和对象（友元、运算符重载、继承、多态）---C++

已于 2024-01-25 17:00:39 修改
阅读量1k 收藏 20
点赞数 22
分类专栏： C++ 文章标签： c++ 开发语言 visual studio windows
于 2024-01-24 16:25:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63685622/article/details/135679573
版权

类和对象

在这里插入图片描述

4.友元

在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术；

友元的目的就是让一个函数或者类访问另一个类中私有成员；
友元的关键字为 friend

友元的三种实现

  • 全局函数做友元
  • 类做友元
  • 成员函数做友元

4.1全局函数做友元

class Building
{
	//告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容
	friend void goodGay(Building* building);

public:

	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}

public:
	//公共权限
	string m_SittingRoom; //客厅

private:
	//私有权限
	string m_BedRoom; //卧室
};

//全局函数
void goodGay(Building* building)
{
	cout << "好朋友正在访问： " << building->m_SittingRoom << endl;
	cout << "好朋友正在访问： " << building->m_BedRoom << endl;
}

void test01()
{
	Building b;
	goodGay(&b);
}

在这里插入图片描述
friend void goodGay(Building* building);

  • 告诉编译器 goodGay全局函数 是 Building类的好朋友，可以访问类中的私有内容

可见，调用test01函数，当全局函数做友元时，该全局函数可以访问私有权限内容。

4.2类做友元

class Building;//先声明，防止goodGay类出错
class goodGay
{
public:
	//类内声明，类外实现
	goodGay();
	void visitor();
	~goodGay();

private:
	Building* building;
};

class Building
{
	//告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
	friend class goodGay;

public:
	Building();

public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

//类外实现成员函数（注意加上所在类空间）
Building::Building()//Building类构造函数
{
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}
goodGay::goodGay()//goodGay类构造函数
{
	//堆区开辟空间，注意要释放（析构函数释放，delete）
	building = new Building;
}
goodGay::~goodGay()
{
	if(building!=NULL)
	{
		delete building;
		building=NULL;
	}
}
void goodGay::visitor()
{
	cout << "好朋友正在访问" << building->m_SittingRoom << endl;
	cout << "好朋友正在访问" << building->m_BedRoom << endl;
}

void test01()
{
	goodGay gg;
	gg.visitor();

}

在这里插入图片描述
== friend class goodGay;==

  • 告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容

可见，调用test01函数后，当类做友元时，该类内可以访问另一个类内的私有权限内容。

4.3成员函数做友元

class Building;//先声明，防止goodGay类出错
class goodGay
{
public:

	goodGay();
	void visitor1(); //只让visitor1函数作为Building的好朋友，可以发访问Building中私有内容
	void visitor2();

private:
	Building* building;
};

class Building
{
	//告诉编译器  goodGay类中的visitor1成员函数 是Building好朋友，可以访问私有内容
	friend void goodGay::visitor1();

public:
	Building();

public:
	string m_SittingRoom; //客厅
private:
	string m_BedRoom;//卧室
};

Building::Building()
{
	this->m_SittingRoom = "客厅";
	this->m_BedRoom = "卧室";
}
goodGay::goodGay()
{
	building = new Building;
}

void goodGay::visitor1()
{
	cout << "好朋友1正在访问" << building->m_SittingRoom << endl;
	cout << "好朋友1正在访问" << building->m_BedRoom << endl;
}
void goodGay::visitor2()
{
	cout << "好朋友2正在访问" << building->m_SittingRoom << endl;
	//cout << "好朋友正在访问" << building->m_BedRoom << endl;//无法访问
}

void test01()
{
	goodGay  gg;
	gg.visitor1();
	gg.visitor2();

}

在这里插入图片描述
friend void goodGay::visitor1();

  • 告诉编译器 goodGay类中的visitor1成员函数 是Building好朋友，可以访问私有内容

可见，调用test01函数后，当一个类内的成员函数做另一个类的友元时，该类内的成员函数可以访问另一个类内的私有权限内容。

5.运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。

5.1 加号运算符重载

作用：实现两个自定义数据类型相加的运算。

对于内置数据类型，编译器知道如何进行运算：
例如两个整型数据的相加，可以直接应用，但对于一些非内置数据类型，比如两个对象的相加，编译器内部没有相关运算方式，故需要我们自己对运算符进行补充。

如果不进行运算符重载，就会出现下面类似的错误：
在这里插入图片描述

5.1.1成员函数实现运算符重载

实例：实现两个对象的相加

class Person {
public:
	Person() {};//为了提供对无参构造函数的调用
	//若无，自己定义了有参构造函数，系统默认无无参构造函数
	//则Person temp;无法成立
	Person(int a, int b)//有参构造
	{
		this->m_A = a;
		this->m_B = b;
	}
	//成员函数实现 + 号运算符重载
	//函数名operator+系统默认，可以实现简化调用
	//自己定义函数名也可，但无法实现下面的简化调用
	Person operator+(const Person& p) {
		Person temp;//无参构造
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;//值返回（重新创建新对象）
	}

public:
	int m_A;
	int m_B;
};

//运算符重载 可以发生函数重载 
//同一函数名表示不同运算
Person operator+(const Person& p2, int val)
{
	Person temp;
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}

//测试函数
void test() {

	Person p1(10, 10);
	Person p2(20, 20);

	//成员函数方式
	//本质调用为：
	//Person p3=p2.operaor+(p1)
	Person p3 = p2 + p1; 
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;

	//本质调用为：
	//Person p4=operaor+(p3，10)
	Person p4 = p3 + 10; 
	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;

}

在这里插入图片描述

5.1.2全局函数实现运算符重载

示例：

class Person {
public:
	Person(int a, int b)//有参构造
	{
		this->m_A = a;
		this->m_B = b;
	}

public:
	int m_A;
	int m_B;
};

//全局函数实现 + 号运算符重载
//对象+对象
Person operator+(const Person & p1, const Person & p2) {
	Person temp(0, 0);
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
//运算符重载 可以发生函数重载 
//对象+int
Person operator+(const Person& p2, int val)
{
	Person temp(0,0);
	temp.m_A = p2.m_A + val;
	temp.m_B = p2.m_B + val;
	return temp;
}

void test() {

	Person p1(10, 10);
	Person p2(20, 20);

	//成员函数方式
	//本质实现：
	Person p3 = operator+ (p1, p2);
	//Person p3 = p2 + p1;  
	cout << "mA:" << p3.m_A << " mB:" << p3.m_B << endl;

	//本质实现：Person p4 = operator+ (p3, 10);
	Person p4 = p3 + 10; 
	cout << "mA:" << p4.m_A << " mB:" << p4.m_B << endl;
}

在这里插入图片描述

总结1：对于内置的数据类型的表达式的的运算符是不可能改变的;
总结2：不要滥用运算符重载。（即不可命名为加号运算符重载，实现用减法）

5.2 左移运算符重载

作用：可以输出自定义数据类型。

5.2.1全局函数实现运算符重载

示例：

class Person {
	//友元：实现对私有权限成员的访问
	friend ostream& operator<<(ostream& out, Person& p);

public:

	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	

private:
	int m_A;
	int m_B;
};

//全局函数实现左移重载
//ostream对象只能有一个
ostream& operator<<(ostream& out, Person& p) {
	out << "a:" << p.m_A << " b:" << p.m_B;
	return out;
}

void test() {

	Person p1(10, 20);
	cout << p1 << "hello world" << endl; //链式编程
}

在这里插入图片描述

5.2.2成员函数实现运算符重载

示例：

  • 1.对象本身做形参
class Person {

public:

	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	//成员函数 实现左移运算符重载，可以实现，但不是我们想要的效果
	ostream& operator<<(Person& p){
		cout << "a:" << p.m_A << " b:" << p.m_B;
		return cout;//链式编程
	}	
private:
	int m_A;
	int m_B;
};

void test() {

	Person p1(10, 20);
	p1.operator<<(p1)<<endl;
	//简化
	p1 << p1 << " hello world" <<endl;//与内置函数实现不一致
}

在这里插入图片描述

  • 2.标准输出流做形参

示例：

class Person {

public:

	Person(int a, int b)
	{
		this->m_A = a;
		this->m_B = b;
	}

	//成员函数 实现左移运算符重载，可以实现，但不是我们想要的效果
	ostream& operator<<(ostream &out) {
		out << "a:" << this->m_A << " b:" << this->m_B;;
		return cout;//链式编程
	}

private:
	int m_A;
	int m_B;
};

void test() {

	Person p1(10, 20);
	//本质实现：
	//p1.operator<<(cout);
	p1 << cout << " hello world" << endl;//可见与内置函数输出不一致
}

利用成员函数重载左移运算符，无法实现与内置输出一致的顺序（即cout<<p,cout在左侧），故不会利用成员函数重载<<运算符。

总结：重载左移运算符配合友元可以实现输出自定义数据类型

5.3 递增/递减运算符重载

作用： 通过重载递增运算符，实现自己的整型数据；

5.3.1 前置++

5.3.1.1成员函数实现运算符重载

示例：

class MyInteger {

	friend ostream& operator<<(ostream& out, MyInteger myint);

public:
	MyInteger() {
		m_Num = 0;
	}
	//前置++
	//局部函数实现
	//返回引用
	MyInteger& operator++() {
		//先++
		m_Num++;
		//再返回
		return *this;//返回对象本身（引用），实现对一直对一个对象进行递增操作
	}

private:
	int m_Num;
};

//左移运算符重载：全局函数
ostream& operator<<(ostream& out, MyInteger myint) {
	out << myint.m_Num;
	return out;
}

//前置++ 先++ 再返回
void test01() {
	MyInteger myInt;
	cout << ++(++myInt) << endl;
	cout << myInt << endl;
//本质实现：
//operator<<(cout, myInt.operator++())<<endl;//相当于cout << ++myInt << endl;
//cout << myInt.operator++().operator++() << endl;//相当于cout << ++(++myInt) << endl;
}

分析：++myInt：m_Num=1（返回对象本身）；
++(++myInt)（对同一个对象++） ：m_Num=2（返回对象本身）；

在这里插入图片描述

  • 如果将返回值改为值返回：即
//值返回
MyInteger operator++() {
	//先++
	m_Num++;
	//再返回
	return *this;//拷贝一个新对象
}

分析：++myInt（第一次：对象本身++）：m_Num=1（创建新对象）；
++(++myInt)（对新对象++）：m_Num=2（返回新对象）；

  • 即cout << ++(++myInt) << endl中的++(++myInt)不再是原对象，而是创建的第二个新对象（其内容和返回对象本身结束的时候一样）；
    cout << myInt << endl;输出对象本身。

在这里插入图片描述
可见，返回类型不同，最后结果不同。

  • 返回对象本身（引用）：实现对一直对一个对象进行递增操作,每一次++都对同一个进行运算。
  • 值返回方式：第一次调用++是对对象本身进行，但之后回利用拷贝构造函数创建一个新的对象，就形成了每次调用都会形成一个新对象，无法实现如同第一种（返回引用）的对同一个对象持续累加。
5.3.1.2全局函数实现运算符重载
MyInteger& operator++(MyInteger &myInt) {
	//先++
	myInt.m_Num++;
	//再返回
	return myInt;//返回对象本身（引用）
}

注:全局函数下，要实现链式访问只能返回对象本身（返回引用）；

5.3.2 后置++

在这里插入图片描述
对于后置++，无法实现链式编程。故对于后置++的重载也无法实现链式编程。
报错原因：表达式必须是可修改的左值。

5.3.2.1成员函数实现运算符重载

示例：

class MyInteger {

	friend ostream& operator<<(ostream& out, MyInteger myint);
public:
	MyInteger() {
		m_Num = 0;
	}
	
	//后置++
	MyInteger operator++(int) {
		//先返回
		MyInteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
		m_Num++;
		return temp;
	}

private:
	int m_Num;
};
//左移运算符重载：全局函数
ostream& operator<<(ostream& out, MyInteger myint) {
	out << myint.m_Num;
	return out;
}

//后置++ 先返回 再++
void test02() {

	MyInteger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
	//本质实现：
	//operator<<(cout, myInt.operator++(0))<<endl;
	//operator<<(cout, myInt)<<endl;
}

在这里插入图片描述

MyInteger operator++(int)：int-占位参数

5.3.2.2全局函数实现运算符重载

示例：

//int为占位参数，为了和前置++区分；调用时需补占位参数（任意数都可）
MyInteger operator++(MyInteger& myInt,int) {
	//先返回
	MyInteger temp = myInt; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
	myInt.m_Num++;
	return temp;
}

//后置++ 先返回 再++
void test02() {

	MyInteger myInt;
	cout << myInt++ << endl;
	cout << myInt << endl;
	// 
	//本质实现：
	//operator<<(cout, operator++(myInt,0)) << endl;
	//operator<<(cout, myInt)<<endl;

}

5.3.3 前置–

5.3.3.1成员函数实现运算符重载

参考前置++：（前置–可以实现链式编程，只列写返回对象本身）

MyInteger& operator--() {
	//先--
	m_Num--;
	//再返回
	return *this;//返回对象本身（引用），实现对一直对一个对象进行递增操作
}
5.3.3.2全局函数实现运算符重载
MyInteger& operator--(MyInteger& myInt) {
	//先++
	myInt.m_Num--;
	//再返回
	return myInt;//返回对象本身（引用）
}

5.3.4 后置–

参见后置++：

5.3.4.1成员函数实现运算符重载
//后置--
MyInteger& operator--(int) {
	//先返回
	MyInteger temp = *this; //记录当前本身的值，然后让本身的值减1，但是返回的是以前的值，达到先返回后--；
	m_Num--;
	return temp;
}
5.3.4.2全局函数实现运算符重载
//int为占位参数，为了和前置--区分；调用时需补占位参数（任意数都可）
MyInteger operator--(MyInteger& myInt,int) {
	//先返回
	MyInteger temp = myInt; //记录当前本身的值，然后让本身的值减1，但是返回的是以前的值，达到先返回后--；
	myInt.m_Num--;
	return temp;
}

递增/递减运算符重载总结： 前置递增返回引用，后置递增返回值.

5.4 赋值运算符重载

c++编译器至少给一个类添加4个函数:

  1. 默认构造函数(无参，函数体为空)
  2. 默认析构函数(无参，函数体为空)
  3. 默认拷贝构造函数，对属性进行值拷贝
  4. 赋值运算符 operator=, 对属性进行值拷贝

前三个之前介绍过，此处着重介绍第四个：
如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题 。
深浅拷贝

示例：

class Person
{
public:

	Person(int age)
	{
		//将年龄数据开辟到堆区
		m_Age = new int(age);
	}

	//重载赋值运算符 
	Person& operator=(Person& p)
	{
		//判断是否有属性在堆区，若有先释放干净，再进行深拷贝
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//编译器提供的代码是浅拷贝
		//m_Age = p.m_Age;

		//提供深拷贝 解决浅拷贝的问题
		m_Age = new int(*p.m_Age);

		//返回自身
		return *this;//链式编程
	}


	~Person()
	{
		//释放堆区空间
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//年龄的指针
	int* m_Age;

};
void test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(30);

	p3 = p2 = p1; //赋值操作：链式编程

	cout << "p1的年龄为：" << *p1.m_Age << endl;
	cout << "p2的年龄为：" << *p2.m_Age << endl;
	cout << "p3的年龄为：" << *p3.m_Age << endl;
}

在这里插入图片描述
附：
参照内置类型赋值的链式程序。

int a = 10;
int b = 20;
int c = 30;

c = b = a;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;

在这里插入图片描述

5.5 关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作。

5.5.1 关系运算符(==)重载

示例：

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	};

	bool operator==(Person& p)
	{
		if (this->m_Name == p.m_Name && this->m_Age == p.m_Age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	string m_Name;
	int m_Age;
};

void test01()
{

	Person a("Tom", 18);
	Person b("Tom", 25);

	if (a == b)
	{
		cout << "a和b相等" << endl;
	}
	else
	{
		cout << "a和b不相等" << endl;
	}

}

在这里插入图片描述

5.5.2 关系运算符(>)重载

示例：

class Person
{
public:
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	};

	int operator>(Person& p)
	{
	//按字母进行比较
		return this->m_Name.compare(p.m_Name);
		//compare按照每一个字母的ASCII值进行比较，根据结果返回0，大于0，小于0
	}

	string m_Name;
	int m_Age;
};

void test01()
{

	Person a("Tom", 18);
	Person b("Marry", 25);

	if ((a > b) == 0)
	{
		cout << "a==b" << endl;
	}
	else if ((a > b) > 0)
	{
		cout << "a>b" << endl;
	}
	else
		cout << "a<b" << endl;
}

在这里插入图片描述

5.6 函数调用运算符重载

  • 函数调用运算符 () 也可以重载；
  • 由于重载后使用的方式非常像函数的调用，因此称为仿函数；
  • 仿函数没有固定写法，非常灵活。

示例：

class MyAdd
{
public:
	int operator()(int v1, int v2)
	{
		return v1 + v2;
	}
};

void test01()
{
	MyAdd add;
	int ret = add(10, 10);//相当于：int ret = add.operator()(10, 10)
	cout << "ret = " << ret << endl;

	//匿名对象调用  
	cout << "MyAdd()(100,100) = " << MyAdd()(100, 100) << endl;
}

在这里插入图片描述

6.继承

继承是面向对象三大特性之一

有些类与类之间存在特殊的关系，例如下图中：
在这里插入图片描述
猫和狗都具备动物的属性，同时其又有很多品种（自己的属性）。

我们发现，定义这些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。
这个时候我们就可以考虑利用继承的技术，减少重复代码。

6.1 继承的基本语法

继承的语法：class 子类 : 继承方式 父类
借助下面的事例，介绍继承的优势和语法：

例如：
我们看到很多网站（以某网站编程培训为例）中，都有公共的头部，公共的底部，甚至公共的左侧列表，只有中心内容不同；接下来我们分别利用普通写法和继承的写法来实现网页中的内容，看一下继承存在的意义以及好处：

普通实现：

//Java页面
class Java 
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	
	void content()
	{
		cout << "JAVA学科视频" << endl;
	}
};
//Python页面
class Python
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	
	void content()
	{
		cout << "Python学科视频" << endl;
	}
};
//C++页面
class CPP 
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}
	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << endl;
	}
	
	void content()
	{
		cout << "C++学科视频" << endl;
	}
};

//测试函数
void test01()
{
	//Java页面
	cout << "Java下载视频页面如下： " << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.content();
	cout << "--------------------" << endl;

	//Python页面
	cout << "Python下载视频页面如下： " << endl;
	Python py;
	py.header();
	py.footer();
	py.content();
	cout << "--------------------" << endl;

	//C++页面
	cout << "C++下载视频页面如下： " << endl;
	CPP cp;
	cp.header();
	cp.footer();
	cp.content();

}

可见，对于上述代码，有一部分代码多次重复引用，虽然结构清晰，但会造成代码冗余，内存浪费。
借助继承的特性可以实现简化：

继承实现：

//公共页面
class BasePage
{
public:
	void header()
	{
		cout << "首页、公开课、登录、注册...（公共头部）" << endl;
	}

	void footer()
	{
		cout << "帮助中心、交流合作、站内地图...(公共底部)" << 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;
	}
};

在这里插入图片描述
将普通实现的每个类内容替换，测试函数不变，会实现如上的结果。

总结：

继承的好处：可以减少重复的代码
class A : public B
A 类称为子类 或 派生类
B 类称为父类 或 基类

派生类中的成员，包含两大部分：

一类是从基类继承过来的，一类是自己增加的成员。
从基类继承过过来的表现其共性，而新增的成员体现了其个性。

6.2继承的方式

继承的语法：class 子类 : 继承方式 父类

继承方式一共有三种：

  • 公共继承
  • 保护继承
  • 私有继承
    不同继承方式下，对于父类的不同权限的内容的访问条件，可以用下面的图进行说明。
    在这里插入图片描述
    可联系，封装权限中的保护权限和私有权限的区别：
  • protected 保护权限 ：类内可以访问 类外不可以访问（例如：儿子可以访问到父亲中的保护内容）
  • private 私有权限 ：类内可以访问 类外不可以访问（例如：儿子不可以访问到父亲中的私有内容）

6.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 = " << sizeof(Son) << endl;
}

在这里插入图片描述
可见，虽然子类无法访问父类中的私有权限内容，但子类大小是包含父类中的私有权限的。
下面借助VS自带的开发人员命令提示符窗口，对上述内容进行一个深入介绍:

在这里插入图片描述
由上图可知，对于Son类中，包含父类的全部内容（三种权限内容都被继承下来）和自己的特有内容，虽然对于公共继承而言，父类中私有权限无法访问，但其也被子类继承，只是被编译器隐藏。

6.4继承中的构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数；
问题：父类和子类的构造和析构顺序是谁先谁后？

  • 继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反。
    示例：
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;
}

在这里插入图片描述

总结：继承中 先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反。
（可对比类对象作为类成员的构造和析构函数调用顺序）2.7类对象作为类成员

6.5继承同名成员处理方式

6.5.1继承非静态同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

  • 访问子类同名成员 直接访问即可；
  • 访问父类同名成员 需要加作用域。
6.5.1.1非静态同名成员变量处理方式

示例：

//父类
class Base {
public:
	Base()
	{
		m_A = 100;
	}
	
public:
	int m_A;
};

//子类
class Son : public Base {
public:
	Son()
	{
		m_A = 200;
	}
public:
	int m_A;
};

void test01()
{
	//子类和父类都有m_A成员变量
	Son s;
	cout << "Son类下m_A:" << s.m_A << endl;

	cout << "Base类下m_A:" << s.m_A << endl;
	cout << "Base类下m_A:" << s.Base::m_A << endl;
}

在这里插入图片描述
可见，子类和父类中有同名成员变量时，如要访问父类中成员变量需要加上父类所在作用域。

6.5.1.2非静态同名成员函数处理方式

当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数;
如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域.

示例：

//父类
class Base {
public:
	
	void func()
	{
		cout << "Base - func()调用" << endl;
	}

	void func(int a)
	{
		cout << "Base - func(int a)调用" << endl;
	}

public:
	int m_A;
};

//子类
class Son : public Base {
public:
	void func()
	{
		cout << "Son - func()调用" << endl;
	}
public:
	int m_B;
};

void test02()
{
	Son s;

	s.func();
	//s.func(10);//报错
	s.Base::func();
	s.Base::func(10);
}

在这里插入图片描述
总结：

  1. 子类对象可以直接访问到子类中同名成员
  2. 子类对象加作用域可以访问到父类同名成员
  3. 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

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

问题：继承中同名的静态成员在子类对象上如何进行访问？

静态成员和非静态成员出现同名，处理方式一致

  • 访问子类同名成员 直接访问即可；
  • 访问父类同名成员 需要加作用域。
6.5.2.1同名静态成员变量处理方式

示例：

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()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;

	//通过类名访问
	cout << "通过类名访问： " << endl;
	cout << "Son  下 m_A = " << Son::m_A << endl;
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

在这里插入图片描述
对于静态同名成员变量，子类和父类中成员变量的访问有两种方式:

  • 通过对象访问：子类对象直接访问子类同名成员，父类成员访问需要子类对象加上父类作用域；
  • 通过类名访问：子类对象可以直接在子类类名直接访问，父类成员需要在子类对象类名的基础上加上父类的作用域。
    • Son::Base::m_A 中第一个::代表通过类名方式访问；第二个::代表访问父类作用域下。
6.5.2.2同名静态成员函数处理方式

同同名静态成员变量访问一样。
示例：

class Base {
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base - static void func(int a)" << endl;
	}

	static int m_A;
};

class Son : public Base {
public:
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
	static int m_A;
};

//同名成员函数
void test02()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	s.func();
	s.Base::func();
	s.Base::func(10);

	//通过类名访问
	cout << "通过类名访问： " << endl;
	Son::func();
	Son::Base::func();
	//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
	Son::Base::func(100);
}

在这里插入图片描述

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象 和 通过类名）

大总结：

  • 访问子类同名成员 直接访问即可
  • 访问父类同名成员 需要加作用域

6.6多继承语法

C++允许一个类继承多个类
语法： class 子类 ：继承方式 父类1 ， 继承方式 父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分。
注：C++实际开发中不建议用多继承

示例：

//父类1
class Base1 {
public:
	Base1()
	{
		m_A = 100;
	}
public:
	int m_A;
};

//父类2
class Base2 {
public:
	Base2()
	{
		m_A = 200;  
	}
public:
	//同名成员变量
	int m_A;
};

//语法：class 子类：继承方式 父类1 ，继承方式 父类2 
class Son : public Base2, public Base1
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
public:
	int m_C;
	int m_D;
};

//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}

在这里插入图片描述
下面借助VS自带的开发人员命令提示符窗口，对上述内容进行一个深入介绍:
在这里插入图片描述

总结： 多继承中如果父类中出现了同名情况，子类使用时候要加作用域

6.7菱形继承

菱形继承概念：
​ 两个派生类继承同一个基类；
​ 又有某个类同时继承者两个派生类；
​ 这种继承被称为菱形继承，或者钻石继承。
典型的菱形继承案例：
在这里插入图片描述
在上图中，羊和驼都继承了动物中的属性，同时羊驼又分别继承两者的属性，就会造成羊驼中重复包含动物属性，造成浪费。即：

菱形继承问题：

  1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性（不知道继承谁的）。
  2. 草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

普通示例：

class Animal
{
public:
	int m_Age;
};

class Sheep :  public Animal {};
class camel :  public Animal {};//camel-骆驼
class alpaca : public Sheep, public camel {};//alpaca-羊驼

void test01()
{
	alpaca st;
	st.Sheep::m_Age = 100;
	st.camel::m_Age = 200;

	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.camel::m_Age = " << st.camel::m_Age << endl;
}

在这里插入图片描述
对于，羊和驼中都含有动物中年龄成员变量，羊驼中就会含有两份年龄成员变量，就会造成以哪个为准呢？
虽然我们可通过添加作用域进行区分，但仍会造成内存浪费，毕竟羊驼只需要一份就可。这个问题可以通过下面的方式进行解决：

优化示例：

虚继承：

  • 继承前加virtual关键字后，变为虚继承
  • 此时公共的父类Animal称为虚基类
class Animal
{
public:
	int m_Age;
};

class Sheep : virtual public Animal {};
class camel : virtual public Animal {};//camel-骆驼
class alpaca : public Sheep, public camel {};//alpaca-羊驼

void test01()
{
	alpaca st;
	st.Sheep::m_Age = 100;
	st.camel::m_Age = 200;

	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.camel::m_Age = " << st.camel::m_Age << endl;
	cout << "st.m_Age = " << st.m_Age << endl;

	st.Sheep::m_Age = 300;
	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.camel::m_Age = " << st.camel::m_Age << endl;
	cout << "st.m_Age = " << st.m_Age << endl;
}

在这里插入图片描述
可以看出，采用虚继承方式，羊驼继承动物的属性就变成了一份，无论改变羊和驼中哪个属性，三者中的属性变量就都改变了。
下面借助VS自带的开发人员命令提示符窗口，对上述内容进行一个深入介绍:

  • 普通示例：
    在这里插入图片描述
  • 优化示例：
    在这里插入图片描述
    对比两者，我们可以方向，参与虚继承方式下，动物类中属性（m_Age）只含有一份。
    虚继承下，羊和驼类中包含一个指针（vbptr-virtual base pointer虚基类指针）指向vbtable（虚基类表-图中1和2的位置），羊和驼中的虚基类表包含各自的偏移量，用于找到动物类中的属性（m_Age），羊和驼就不再分别基础动物类中的属性了，只继承一个指针用于找到动物类的属性，减少空间浪费。

总结：

  • 菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
  • 利用虚继承可以解决菱形继承问题

7.多态

在编程语言和类型论中，多态（英语：polymorphism）指为不同数据类型的实体提供统一的接口。
多态类型（英语：polymorphic type）可以将自身所支持的操作套用到其它类型的值上。

7.1 多态的基本应用

7.1.1 多态的基本概念

多态是C++面向对象三大特性之一

多态分为两类：

  • 静态多态: 函数重载和运算符重载属于静态多态，复用函数名；
  • 动态多态: 派生类（子类）和虚函数实现运行时多态。

静态多态和动态多态区别：

  • 静态多态的函数地址早绑定 - 编译阶段确定函数地址；
  • 动态多态的函数地址晚绑定 - 运行阶段确定函数地址。

非多态示例：

class Animal
{
public:
	void speak()
	{
		cout << "动物在说话" << endl;
	}
};

class Cat :public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};

class Dog :public Animal
{
public:

	void speak()
	{
		cout << "小狗在说话" << endl;
	}

};

//希望实现每次调用函数，给什么形参就调用谁的函数
//提供一个公共接口，否则就需要多个函数才可实现对每个动物叫的实现
void DoSpeak(Animal& animal)
{
	animal.speak();
}

void test01()
{
	Cat cat;
	DoSpeak(cat);

	Dog dog;
	DoSpeak(dog);
}

在这里插入图片描述
但由输出来看与我们的想法不同，每次都调用动物类的说话函数（speak）。

原因：
由于doSpeak函数在编译阶段就确定了函数地址，即地址早绑定——静态多态

对于此种问题可以采用多态技术进行解决：

要实现调用谁，谁执行就需要使得doSpeak函数地址在运行阶段进行绑定，实现地址晚绑定——动态多态。

多态示例：
只需要在父类speak函数前添加关键字-virtual，形成虚函数。

class Animal
{
public:
	//Speak函数就是虚函数
	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};
//我们希望传入什么对象，那么就调用什么对象的函数
//如果函数地址在编译阶段就能确定，那么静态联编
//如果函数地址在运行阶段才能确定，就是动态联编

在这里插入图片描述

多态满足条件：
1、有继承关系（继承是多态实现的基础）；
2、子类重写父类中的虚函数:

  • 也就是与父类虚函数一样（关键字virtual可加可不加），返回值类型 函数名 形参列表完全一致。

多态使用： 父类指针或引用指向子类对象，即：
void DoSpeak(Animal& animal)-父类引用；
void DoSpeak(Animal* animal)-父类指针。

7.1.2 多态的基本原理

class Animal
{
public:
	//Speak函数就是虚函数
	//函数前面加上virtual关键字，变成虚函数，那么编译器在编译的时候就不能确定函数调用了。
	virtual void speak()
	{
		cout << "动物在说话" << endl;
	}
};

class Cat :public Animal
{
public:
	void speak()
	{
		cout << "小猫在说话" << endl;
	}
};

class Dog :public Animal
{
public:

	void speak()
	{
		cout << "小狗在说话" << endl;
	}

};

//希望实现每次调用函数，给什么形参就调用谁的函数
//提供一个公共接口，否则就需要多个函数才可实现对每个动物叫的实现
void DoSpeak(Animal& animal)
{
	animal.speak();
}

void test01()
{
	Cat cat;
	DoSpeak(cat);
}

对于多态来说，需要满足两个条件，继承和重写虚函数。

  • 在子类未重写父类的虚函数时：
    在这里插入图片描述
    子类(猫类)由于继承父类，因此在子类未重写父类虚函数时，子类中将父类中的虚函数完全复制一份。
    （图中，父类存储一个指针（即vfptr），其指向vftable-虚函数表，表中放着虚函数的地址）
    下面借助VS自带的开发人员命令提示符窗口，对上述内容进行一个深入介绍:
    在这里插入图片描述
    在这里插入图片描述

  • 子类重写父类虚函数
    在这里插入图片描述
    子类虚函数表内部就替换成子类的（虚）函数地址，子类就有了自己的（虚）函数，从而可以进行调用自己的函数。
    下面借助VS自带的开发人员命令提示符窗口，对上述内容进行一个深入介绍:
    在这里插入图片描述

  • 父类指针或引用指向子类对象

void DoSpeak(Animal& animal)
{
	animal.speak();
}
//父类函数传入子类对象：DoSpeak(cat);
//Animal& animal=Cat；
//再进行调用父类函数：animal.speak();
//由于Animal& animal=Cat，指向子类对象（Cat），编译器就会在子类的虚函数表中去找内部的函数地址，从而调用子类函数。

7.2 纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容；
因此可以将虚函数改为纯虚函数。

纯虚函数语法：virtual 返回值类型 函数名 （参数列表）= 0 ;
当类中有了纯虚函数，这个类也称为抽象类

抽象类特点：

  • 无法实例化对象；
  • 子类必须重写抽象类中的纯虚函数，否则也属于抽象类。
    示例：
class Base
{
public:
	//纯虚函数
	//类中只要有一个纯虚函数就称为抽象类
	virtual void func() = 0;
};

class Son :public Base
{
public:
	//子类必须重写父类中的纯虚函数，否则也属于抽象类
	virtual void func()
	{
		cout << "func调用" << endl;
	};
};

void test01()
{
	Base* base = NULL;
	//base = new Base; // 错误，抽象类无法实例化对象
	//父类指针指向子类对象
	base = new Son;
	base->func();//通过父类指针调用子类函数
	delete base;//记得销毁
}

7.3 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
问题示例：

class Animal {
public:

	Animal()
	{
		cout << "Animal 构造函数调用！" << endl;
	}
	virtual void Speak() = 0;

	~Animal()
	{
		cout << "Animal析构函数调用！" << endl;
	}
};

class Cat : public Animal {
public:
	Cat(string name)
	{
		cout << "Cat构造函数调用！" << endl;
		m_Name = new string(name);
	}
	virtual void Speak()
	{
		cout << *m_Name << "小猫在说话!" << endl;
	}
	~Cat()
	{
		cout << "Cat析构函数调用!" << endl;
		if (this->m_Name != NULL) {
			delete m_Name;
			m_Name = NULL;
		}
	}

public:
	string* m_Name;
};

void test01()
{
	Animal* animal = new Cat("Tom");//父类指针指向子类对象
	animal->Speak();
	delete animal;//释放
}

在这里插入图片描述

由此可知，对于子类在堆区开辟的空间，对父类指针释放未能对子类空间释放，造成内存泄漏。（未能调用子类析构函数）

解决方式：
将父类中的析构函数改为虚析构或者纯虚析构

  • 虚析构和纯虚析构共性：

    • 可以解决父类指针释放子类对象；
    • 都需要有具体的函数实现；

  • 虚析构和纯虚析构区别：

    • 如果是纯虚析构，该类属于抽象类，无法实例化对象。

虚析构语法：

virtual ~类名(){}

纯虚析构语法：（类内声明，类外实现）

类内声明： virtual ~类名() = 0;

类外实现：类名::~类名(){}
示例：

  • 虚析构函数
class Animal {
public:

	Animal()
	{
		cout << "Animal 构造函数调用！" << endl;
	}
	//纯虚函数
	virtual void Speak() = 0;

	法一：析构函数加上virtual关键字，变成虚析构函数
	virtual~Animal()
	{
		cout << "Animal虚析构函数调用！" << endl;
	}
};

在这里插入图片描述

  • 纯虚析构函数
class Animal {
public:

	Animal()
	{
		cout << "Animal 构造函数调用！" << endl;
	}
	//纯虚函数
	virtual void Speak() = 0;

	//法二：类内声明：纯虚析构函数
	//和包含普通纯虚函数的类一样，包含了纯虚析构函数的类也是一个抽象类。不能够被实例化。
	virtual ~Animal() = 0;
};

//法二：类外实现：
Animal::~Animal()
{
	cout << "Animal 纯虚析构函数调用！" << endl;
}

在这里插入图片描述
注意：纯虚析构函数不要忘了类外实现，否则会出现下面的错误;
在这里插入图片描述

总结：

​ 1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象；

​ 2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构；

​ 3. 拥有纯虚析构函数的类也属于抽象类。

木子.李347
关注
  • 22
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
运算符重载与多态练习（面向对象程序设计C++）
07-01
【运算符重载】在C++中，运算符...总结起来，这个实验旨在让学生掌握C++中的运算符重载、虚函数和多态、继承与派生等面向对象编程概念，并通过实际操作加深理解。同时，还涉及到了链表数据结构的创建和对象的动态管理。
C++作业实验-运算符重载
06-20
在这个实验中，我们将探讨如何在类的设计中使用运算符重载，以及它与类、友元函数的关系。 首先，让我们理解什么是运算符重载。在C++中，运算符如`+`, `-`, `*`, `/`等可以被重载，这意味着我们可以为这些运算符...
C++ 重载运算符 继承 多态 （超详细）
日拱一卒,功不唐捐
06-22 4232
（一）重载运算符： （1）声明与定义格式 一般是类内声明，类外定义，虽然可以在类内定义，但 写前面堆一堆不好看！！！ 类内声明： class Demo { 返回值类型 operator 运算符（形参表）； } 类外定义： 返回类型 Demo（类名）：：operator运算符（形参表） { 函数体 } (2）双目运算符重载为成员函数 当重载运算符为双目运算符时，形参表中只有一个参数...
C++ 面向对象 - 运算符重载与友元函数
代码不会敲的博客
06-09 3184
C++ 预定义的运算符的操作对象只能是基本数据类型，但是实际上许多用户自定义类型（例如类），也需要类似的运算符操作，C++ 可以通过运算符重载来满足这种需求。运算符重载本质就是函数重载，也是 C++ 多态的一种形式。同样 C++ 的封装性和数据隐藏性，只有类自身的函数才可以不受限制的访问类的非公有成员；任何非成员函数直接访问类中非公有数据成员会导致编译错误。于是针对这一情况 C++ 推出了友元函数。本实训我们就来学习运算符重载和友元函数的使用。第1关 复数运算 第2关 学生信息转换 第3关 矩阵运算....
【C++知识点】类和对象：友元，运算符重载，多态
yf743909的博客
06-21 331
今天来继续了解类和对象！PS.本博客参考b站up黑马程序员的相关课程，老师讲得非常非常好！
C++面向对象（OOP）编程-运算符重载
发狂的小花的博客
12-15 1048
本文主要介绍C++面向对象编程中的多态的手段之一运算符重载，讲清运算符重载的本质，以及通过代码实现一些常用的运算符重载。
2021-11-08 C++封装继承多态---C++对象模型和this指针、友元、运算符重载（附代码理解）
名幕新星的博客
11-08 744
3. C++对象模型和this指针 1.1 成员变量和成员函数分开存储 在C++中，类内的成员变量和成员函数分开存储，只有非静态成员变量才属于类的对象上。 #include<iostream> using namespace std; class person { int m_a; //非静态成员变量 属于类的对象上的 static int m_b;//静态成员变量 不属于类的对象上的 void func() {} //非静态成员变量 不属于类的对象上的 static vo
C++继承-重载-多态-虚函数
majalis_C的博客
07-22 252
原文链接：https://www.cnblogs.com/smuxiaolei/p/7516086.html C++继承 基类 & 派生类 一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下： // 派生类 class Rectangle: public Shape {...
C++基础篇 第三天 友元和运算符重载
southernbrid的博客
05-05 349
友元函数是一种特殊类型的函数，它能够访问类的私有成员和保护成员。这意味着，即使这些成员被声明为私有或保护的，友元函数也可以在类外部直接访问它们。友元函数的作用主要有以下几个方面：提高程序的效率：如果某个函数需要频繁地访问类的私有成员或保护成员，将其声明为友元函数可以避免通过类的公共接口来访问这些成员，从而提高程序的效率。增加代码的灵活性：友元函数可以访问类的私有成员和保护成员，这使得在某些情况下可以更方便地实现某些功能。
C++运算符重载、友元、继承、多态、文件操作
LonelyBHBH的博客
10-28 254
一、运算符重载 1.加号运算符 定义operator+（）下面直接用+即可 2.左移运算符 ostream& operator<<(ostream& cout, zuoyi& z) 下面直接用 3.递增运算符 //前置++重载 dizeng& operator++()//返回引用是因为 一直对一个做操作 { NUM++; return *this; } //后置++重载 //后置返回的是值不是引用 因为 返回的是...
【C++ 七】类和对象：封装、继承、多态、友元、运算符重载
qq_45138120的博客
04-20 664
本文包含封装的意义、struct和class区别、成员属性设置为私有、构造函数和析构函数、构造函数的分类及调用、拷贝构造函数调用时机、构造函数调用规则、深拷贝与浅拷贝、初始化列表、类对象作为类成员、静态成员、成员变量和成员函数分开存储、this指针概念、空指针访问成员函数、const修饰成员函数、全局函数做友元、类做友元、成员函数做友元、加号运算符重载、左移运算符重载、递增运算符重载、递减运算符重载、赋值运算符重载、关系运算符重载、函数调用运算符重载、继承的基本语法、继承方式、继承中的对象模型......
面向对象C++：ch05 运算符重载及多态.ppt
06-12
面向对象C++：运算符重载及多态 面向对象C++：运算符重载及多态是C++编程语言中的一项重要特性，它允许开发者对已有的运算符赋予多重含义，从而实现用户自定义类型的运算。 运算符重载是指将指定的运算表达式...
c++ 运算符重载和转换
06-05
本篇文章将深入探讨C++中的运算符重载以及相关的函数对象和类型转换。 一、运算符重载的概念 运算符重载并不创建新的运算符，而是为已有的运算符赋予新的意义。重载是通过在类中定义成员函数或友元函数来实现的，...
C++程序设计，主要为C++语言简介、面向对象的基本概念、类和对象进阶、运算符重载、类的继承与派生、多态与虚函数等章节总结
12-18
7. **运算符重载**：C++允许重载运算符，以便为自定义类型赋予自然的运算符行为，如 `+`，`-`，`*` 等。 8. **继承与派生**：继承是类之间的一种关系，派生类可以从基类继承属性和行为。C++支持单继承和多继承。 9...
C++初探究（2）
Frenemy__的博客
07-09 1483
public:// 成员函数private:// 成员变量int* array;size_t top;而我们如果想要对函数定义，则需要专门使用类域来定义函数.
C++(week11): C++基础 第五章: 运算符重载、友元
Edward2022的博客
07-09 1017
友元、运算符重载、类型转换函数、嵌套类、单例模式的自动释放、std::string的三种底层实现
05day--C++日期类的实现与取地址运算符的重载
最新发布
weixin_73863912的博客
07-13 353
• const实际修饰该成员函数隐含的this指针，表明在该成员函数中不能对类的任何成员进⾏修改。const 修饰Date类的Print成员函数，Print隐含的this指针由 Date* const this 变为 const Date* const this。• 将const修饰的成员函数称之为const成员函数，const修饰成员函数放到成员函数参数列表的后⾯。取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，⼀般这两个函数编译器⾃动。⽣成的就可以够我们⽤了，不需要去显⽰实现。
C语言操作符详解
z317920的博客
07-11 606
目录一、操作符分类二、算术操作符三、赋值操作符四、关系操作符 五、条件操作符六、⼆进制和进制转换1.二进制 2.进制转换(1)2进制转10进制(2)10进制转2进制(3)2进制转8进制(4)2进制转16进制七、原码、反码、补码 八、移位操作符1.左移操作符2.右移操作符 九、位操作符1.按位与 &2.按位或 |3.按位异或 ^ 4.按位取反 ~ 十、单目操作符1.逻辑非操作符 ！ 2.自增++、自减-- 3.取地址符&、解引用符*、sizeof 3.1.取地址符& 3.2.解引

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值