C++【类与对象】——运算符重载

已于 2022-04-21 15:43:59 修改
阅读量1.1k 收藏 2
点赞数 1
分类专栏： C++学习 文章标签： c++
于 2022-04-21 15:41:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44721375/article/details/124190405
版权

文章目录


Note:
i.视频为 黑马程序员C++视频（121-126），系列文章为视频听课笔记;
ii.难度指数：++
iii.不论变量、函数名、标识符形式怎样复杂，只要我们考虑编程的本质是对内存的操作，对内存进行分析，一切逻辑都会变得清晰。

一、运算符重载

1.定义

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

二、加号运算符重载

1.code格式

（1）通过成员函数实现加号运算符重载

通过成员函数重载加号，实现两个示例对象属性相加并返回拥有相加属性的新的对象。

//代码示例
#include<iostream>
#include<string>
using namespace std;

class person
{
public:
	int m_A;
	int m_B;
	//通过成员函数实现加号运算符重载
	person operator +(person &p)//定义函数类型为person，
	{
		person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;//返回拥有相加属性的新的对象
	}
};

void test01()
{
	person p1;
	p1.m_A = 10;
	p1.m_B = 20;
	person p2;
	p2.m_A = 10;
	p2.m_B = 20;
	person p3 = p1 + p2;
	cout << p3.m_A << endl;//20
	cout << p3.m_B << endl;//40
}

int main()
{
	test01();
}

（2）通过全局函数实现加号运算符重载

通过全局函数重载加号，实现两个示例对象属性相加并返回拥有相加属性的新的对象。

//代码示例
#include<iostream>
#include<string>
using namespace std;

class person
{
public:
	int m_A;
	int m_B;
};

//通过全局函数实现运算符重载
person operator + (person &p1, person &p2)
{
	person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;//返回拥有相加属性的新的对象
}
void test01()
{
	person p1;
	p1.m_A = 10;
	p1.m_B = 20;
	person p2;
	p2.m_A = 10;
	p2.m_B = 20;
	person p3 = p1 + p2;
	cout << p3.m_A << endl;
	cout << p3.m_B << endl;
}

int main()
{
	test01();
}

2.作用

实现两个自定义数据类型（非编译器内置数据类型）的相加。

3.拓展

（1）运算符重载与函数重载可以同时发生

上述加号运算符重载涉及到operator +函数，也能实现函数重载。
函数重载：函数重载是函数名相同，但传入参数类型等不同的情况下能够实现对不同函数的调用。

//代码示例
#include<iostream>
#include<string>
using namespace std;

class person
{
public:
	int m_A;
	int m_B;
};
//通过全局函数实现运算符重载
person operator + (person &p1, person &p2)
{
	person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}
//全局函数重载，与上面的函数第二个形参类型不同
person operator + (person &p1, int num)
{
	person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}

void test01()
{
	person p1;
	p1.m_A = 10;
	p1.m_B = 20;
	person p2;
	p2.m_A = 10;
	p2.m_B = 20;
	person p3 = p1 + p2;//调用上面第一个全局函数
	cout << "p3.m_A=" << p3.m_A << endl;//20
	cout << "p3.m_B=" << p3.m_B << endl;//40
	person p4 = p1 + 5;//由于加号运算符后面的数据类型为整型，调用上面第二个全局函数实现加号运算符的重载
	cout << "p4.m_A="<< p4.m_A << endl;//15
	cout << "p4.m_B="<< p4.m_B << endl;//25
}

int main()
{
	test01();
}

该图为上述代码的输出，由输出可见，由于加号运算符前后数据类型不同，在进行加法运算时，加号运算符重载时调用的是两个不同的全局函数。
在这里插入图片描述

【一点思考】：
1）重载类似于利用同一个标志符，但使其在不同情况下发挥的作用不同。例如运算符重载是指运算符相同，但数据类型不同时能够实现自定义数据类型的运算；函数重载是函数名相同，但是参数类型等不同的情况下能够实现对不同函数的调用。
2）加号运算符的重载通过定义一个名为operator +的成员函数或者全局函数来实现，当需要定义多个operator +函数实现自定义类型数据的相加运算时，也会发生函数重载的现象。

三、左移运算符重载

左移运算符即<<。

1.code格式

（1）通过全局函数实现左移运算符重载

通过全局函数重载左移运算符，实现自定义数据类型——类的输出。

//代码示例一
#include<iostream>
#include<string>
using namespace std;

class person
{
public:
	int m_A;
	int m_B;
};

void operator << (ostream &out,person &p)//out为cout的引用
{
	out << p.m_A << endl;
	out << p.m_B << endl;
}
void test01()
{
	person p;
	p.m_A = 10;
	p.m_B = 20;
	cout << p;//注意这里调用<<重载函数，所传参数为cout和p！
	cout << p << "hello world" << endl;//报错！
}

int main()
{
	test01();
	return 0;
}

代码示例一运行结果：
在这里插入图片描述

代码示例一能够实现<<重载，但不能实现不断重载，即cout << p <<...会报错，这是因为<<重载函数返回类型是void，void不能继续对重载函数进行调用。要实现对重载函数的不断调用，只要实现重载函数返回值为cout即可，具体代码见示例二。

//代码示例二
#include<iostream>
#include<string>
using namespace std;

class person
{
public:
	int m_A;
	int m_B;
};

ostream & operator << (ostream &out,person &p)
{
	out << p.m_A << endl;
	out << p.m_B << endl;
	return out;
}
void test01()
{
	person p;
	p.m_A = 10;
	p.m_B = 20;
	cout << p << "hello";
}

int main()
{
	test01();
	return 0;
}

代码示例二运行结果：
在这里插入图片描述

2.作用

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

【总结】
1）左移运算符的重载通过定义一个名为operator <<的全局函数来实现；
2）这里出现了新的数据类型，即cout的数据类型：ostream；
cout能作全局函数的参数也是我没想到的hiahiahia

3.拓展

思考：当上述代码示例中类的属性为私有属性时，怎么输出？
答：利用全局函数作友元，在类中加上friend+全局函数声明即可。代码见示例三：

//代码示例三
#include<iostream>
#include<string>
using namespace std;

class person
{
	friend ostream & operator << (ostream &out, person &p);
	friend void test01();
private:
	int m_A;
	int m_B;
};

ostream & operator << (ostream &out,person &p)
{
	out << p.m_A << endl;
	out << p.m_B << endl;
	return out;
}
void test01()
{
	person p;
	p.m_A = 10;
	p.m_B = 20;
	cout << p << "hello";
}

int main()
{
	test01();
	return 0;
}

四、递增运算符重载

1.code格式

（1）前置递增运算符重载

前置递增运算符的作用是：先递增，后执行表达式，具体示例见代码中main函数的前三行。
代码如下所示：

//前置递增运算符重载
#include<iostream>
#include<string>
using namespace std;

class MyInteger 
{
	friend ostream & operator << (ostream &out, MyInteger MyInt);
public:
	//利用构造函数对成员属性进行初始化，不初始化就没有示例的值输出
	MyInteger()
	{
		m_num = 0;
	}
	//通过成员函数重载前置++运算符
	MyInteger& operator ++()//必须返回引用，目的是对一个数据进行操作，否则将返回新的对象的成员属性
	{
		//先递增
		this->m_num++;
		//再将自身返回
		return *this;
	}
private:
	int m_num;
};

//左移运算符重载全局函数
ostream & operator << (ostream &out, MyInteger MyInt)
{
	cout << MyInt.m_num<< endl;
	return out;
}

//测试重载的前置递增效果
void test01()
{
	MyInteger myint;
	//若重载函数返回为非引用，输出结果为：
	cout << ++(++myint) << endl;//2
	cout << myint << endl;//1
	//若重载函数返回为引用，输出结果为：
	cout << ++(++myint) << endl;//2
	cout << myint << endl;//2
}
int main()
{
	//看一下前置递增运算符的作用，重载要实现相同的作用
	int a = 0;
	cout << ++a << endl;//1
	cout << a << endl;//1
	test01();
	return 0;
}

【关于前置递增运算符重载函数返回必须为引用的原因】： 如果重载函数返回值非引用，那么每次++myint后都会创建一个新的MyInteger对象，再进行递增就不是基于实例对象myint了，而是在每次++后创建的新的MyInteger实例对象上。

（2）后置递增运算符重载

后置递增运算符的作用是：先执行表达式，后递增。具体示例见代码中main函数前三行。
代码如下所示：

//后置运算符重载实现
#include<iostream>
#include<string>
using namespace std;

class MyInteger
{
	friend ostream & operator << (ostream &out, MyInteger myint);
public:
	MyInteger()
	{
		m_num = 0;
	}
	MyInteger operator ++(int)//不能返回引用，因为temp仅为局部变量
	{
		//先返回原先的值->先记录先前的值
		MyInteger temp = *this;
		//再递增
		this->m_num++;
		//最后返回
		return temp;
	}
private:
	int m_num;
};

ostream & operator << (ostream &out, MyInteger myint)
{
	cout << myint.m_num;
	return out;
}
void test01()
{
	MyInteger myint;
	cout << myint++ << endl;//0
	cout << myint << endl;//1
}

int main()
{
	//看一下后置递增运算符的作用，重载要实现相同的作用
	int a = 0;
	cout << a++ << endl;//0
	cout << a << endl;//1
	test01();
	return 0;
}

【关于重载函数为什么不能返回引用】：因为temp为局部变量，函数执行结束后即释放。在引用中我们提到，引用作为函数返回值时，不能返回局部变量的引用。

2.作用

通过递增运算符重载，实现自定义的整型数据递增，例如类中某整型成员属性的的递增。同理，上述代码也可进行递减运算符的重载，进而实现自定义整型数据的递减。

五、赋值运算符重载

（1）浅拷贝&深拷贝

【深浅拷贝的起源&图解&解决方法】：
【起源】：前面学到，c++在创建类时会默认分配三个函数
1）默认构造函数（无参，函数体为空）
2）默认析构函数（无参，函数体为空）
3）默认拷贝构造函数（实现对属性的值拷贝）
然而，当创建的类中包含堆区指针数据的成员属性时，若调用默认拷贝构造函数（即浅拷贝）会导致堆区指针内存的重复释放（释放由析构函数实现），进而导致程序无法运行。
实际上，c++在创建类时还会默认分配赋值运算符重载函数，即operator =函数。
【动态图解】：

【解决方法】：
1）自定义拷贝构造函数，实现深拷贝
2）赋值运算符重载

下面我们将从解决浅拷贝方法的角度来介绍赋值运算符重载。

（2）自定义拷贝构造函数解决浅拷贝问题

自定义拷贝构造函数见代码中所示，其开辟了新的堆区内存储存实例对象p1中的成员属性，实现了将实例对象p中指针数据m_age指向的值赋值给p1，而不是单纯的将m_age赋值。

#include<string>
#include<iostream>
using namespace std;

class person 
{
public:
	//创建年龄属性，将其开辟到堆区
	person(int age)
	{
		cout << "构造函数调用" << endl;
		m_age = new int(age);//注意格式
	}
	//自定义拷贝构造函数，实现深拷贝
	person(const person &p)
	{
		cout << "自定义拷贝函数调用" << endl;
		m_age = new int(*(p.m_age));
	}
	~person()
	{
		cout << "析构函数调用" << endl;
		if (m_age != NULL)
		{
			delete m_age;//释放堆区内存
			m_age = NULL;
		}
	}
	int * m_age;
};

void test01()
{
	person p(18);
	person p1(p);
	cout << "p的年龄为：" << *p.m_age << endl;//18
	cout << "p1的年龄为：" << *p1.m_age << endl;//18
}
int main()
{
	test01();
	return 0;
}

上述代码执行的输出结果如下所示：
在这里插入图片描述

（3）赋值运算符重载解决浅拷贝问题

赋值运算符重载函数见代码中person & operator = (person &p)所示：

【思考】：
要学会分析定义重载函数返回值为不同类型的逻辑，如下所示代码中，若定义赋值运算符重载函数的返回值类型为person类，则执行一次重载函数，都会创建一个新的person实例对象。

#include<string>
#include<iostream>
using namespace std;

class person 
{
public:
	person(int age)
	{
		cout << "有参构造函数调用" << endl;
		//创建年龄属性，将其开辟到堆区
		m_age = new int(age);//注意格式
	}
	~person()
	{
		cout << "析构函数调用" << endl;
		if (m_age != NULL)
		{
			delete m_age;
			m_age = NULL;
		}
	}
	person & operator = (person &p)//连续赋值情况下，p3=p2=p1，首先执行p2=p1;这里定义的返回值和返回类型是p2的返回值和类型。若返回值类型为person，则创建的是一个新的person实例对象，报错!
	{
		//编译器默认浅拷贝
		//m_age = p.m_age;
		//先判断是否有p1中属性在堆区，如果有先释放干净
		if (m_age != NULL)
		{
			delete m_age;
			m_age = NULL;
		}
		//指向深拷贝
		m_age = new int(*p.m_age);
		return *this;
	}
	int * m_age;
};

void test01()
{
	person p(18);//堆区创建内存存储
	person p1(20);//堆区创建内存存储
	p1 = p;//调用operator+赋值运算符重载函数
	cout << "p的年龄为："<<*p.m_age<<endl;
	cout << "p1的年龄为：" << *p1.m_age << endl;
}

int main()
{
	//test01();
	int a = 10;
	int b = 20;
	int c = 30;
	c = b = a;//内置数据类型连续赋值
	cout << "a的值为" << a << endl;//10
	cout << "b的值为" << b << endl;//10
	cout << "c的值为" << c << endl;//10
/***********************************************/
	person p1(10);
	person p2(20);
	person p3(30);
	p3 = p2 = p1;//自定义类属性连续赋值
	cout << "p1的值为" << *p1.m_age << endl;//10
	cout << "p2的值为" << *p2.m_age << endl;//10
	cout << "p3的值为" << *p3.m_age << endl;//10
	return 0;
}

六、关系运算符重载

（1）code格式

以关系运算符“==”和“!=”为例，核心函数为bool operator ==(person &p)和bool operator !=(person &p)。

#include<iostream>
#include<string>
using namespace std;

class person 
{
public:
	person(int age, string name)
	{
		m_age = age;
		m_name = name;
	}
	//“==”关系运算符重载
	bool operator ==(person &p)
	{
		if (this->m_age == p.m_age && this->m_name == p.m_name)
		{
			return true;
		}
		else
			return false;
	}
	//“！=”关系运算符重载
	bool operator !=(person &p)
	{
		if (this->m_age != p.m_age || this->m_name != p.m_name)
		{
			return true;
		}
		else
			return false;
	}
	int m_age;
	string m_name;
};

void test01()
{
	person p1(18, "TOM");
	person p2(25, "吴晗");
	person p3(18, "TOM");
	if (p1 == p3)
	{
		cout<<"p1和p3是相等的"<<endl;
	}
	if (p1 != p2)
	{
		cout << "p1和p2是不相等的" << endl;
	}
}

int main()
{
	test01();
	return 0;
}

（2）作用

重载任意关系运算符，实现自定义数据类型的对比。

七、函数调用运算符重载（重点）

（1）code格式

函数调用运算符即()，该部分涉及()的重载。

//运算符()重载
#include<iostream>
#include<string>
using namespace std;

//利用重载实现打印输出
class Myprint
{
public:
	void operator ()(string zfc)
	{
		cout << zfc << endl;
	}
};
//利用重载实现两数相加
class Myadd 
{
public:
	int operator()(int num1, int num2)
	{
		return num1 + num2;
	}
};
//测试打印输出
void test01()
{
	Myprint p1;
	p1("hhhhhhhhhhhh");//使用起来非常像函数调用，因此运算符()重载函数在使用时也称为仿函数
	Myprint()("吴晗");//匿名函数对象，涉及实例对象以及重载函数，执行完后立即释放

}
//测试两数相加
void test02()
{
	Myadd shs;
	int sum1 = shs(12, 13);
	cout << "两数之和=" << sum1 << endl;//25
	int sum2 = Myadd()(19, 81);
	cout << "两数之和=" << sum2 << endl;//100
}

int main()
{
	test01();
	test02();
	return 0;
}

（2）作用

知道运算符()也可以重载，了解仿函数以及匿名函数对象，后面学习STL会经常用到。

【总结】：
1）仿函数：由于运算符()重载函数的使用与函数调用类似，因此其在使用时被称为仿函数。
2）匿名函数对象：类名+()即为一个匿名函数对象，执行完后立即释放。

八、全文总结

C++【类与对象】——运算符重载串讲，涉及：
1)加号运算符，+：实现自定义数据类型相加
2)左移运算符，<<:实现自定义数据类型输出
3)递增运算符，前置++、后置++：实现自定义数据类型递增
4)关系运算符，==、!=：实现自定义数据类型比较操作
5)函数调用运算符，()：定义()实现自定义功能
核心函数为operator加上述运算符，难点为重载运算符的连续调用。

hanhan@
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 面向对象- -运算符的重载（三）
徐小mu的博客
01-01 455
目录 不同类型数据间的转换 1、标准类型数据间的转换 2、转换构造函数 3、类型转换函数 关于运算符重载的归纳   不同类型数据间的转换 1、标准类型数据间的转换 在以前我们对一个变量初始化或者不同数据间进行运算时，都会涉及到数据类型的转换，只是有显式和隐式的区别。隐式类型转换是编译系统自动完成的，不需要用户干预，例： int i=6; i=7.5+i; 编译系统对 7.5...
c++——运算符重载（四） 源码
09-09
在C++编程语言中，运算符重载是一项重要的特性，它允许我们为已有的运算符赋予新的含义，以便在自定义类型上使用。本篇内容将深入探讨C++中的运算符重载，通过一个综合的Demo来展示其功能和用法。 首先，运算符重载...
类和对象————运算符重载
zcolaz的博客
02-20 439
对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型 .1加号运算符重载 实现自定义数据类型相加。 成员函数实现 全局函数实现 class Person { public: int m_a; int m_b; //1.全局函数实现 //Person operator+(Person& p) { // Person temp; // temp.m_a = this->m_a + p.m_a; // temp.m_b = this->m_b + p.m_b
类和对象-C++运算符重载
lyxawdn的博客
03-16 1301
运算符重载概念：对已有的运算符重新定义，赋予其另一种功能，以适应不同的数据类型。 一、加号运算符重载 编译器本身掌握了1+1=2、 2+2=4之类的运算（内置数据类型），但当两个自定义的数据类型需要进行相加运算时，编译器不知道怎么处理。 我们当然可以通过函数来实现自定义数据类型的相加 class Person { public: int m_A; int m_B; }; Person p1; p1.m_A = 10; p2.m_B = 10; Person p2; p2.m_A = 10; p2.m_B
运算符重载
weixin_50920066的博客
01-14 150
加号运算符重载 作用：实现两个自定义数据类型相加的运算 class Person { public: Person() {}; Person(int a, int b) { this->m_A = a; this->m_B = b; } //成员函数实现 + 号运算符重载 Person operator+(const Person& p) { Person temp; temp.m_A = this->m_A + p.m_A; temp.m_B =
C++基础（六）在对象中使用运算符——运算符重载
浮生流年的博客
01-14 941
C++语言允许程序员重新定义已有的运算符，使其能够按用户的要求完成一些特定的操作，这就是运算符重载。经重载后的运算符重载。经重载后的运算符能够直接对用户自定义的数据进行操作运算。本章介绍有运算符重载方面的内容。 C++语言为实现运算符重载提供了一种方法，即将运算符看作一种特殊类型的函数，运算符重载是通过对运算符的重载实现的。运算符函数名由关键字operator和重载的运算符组成。 重载运算符的
C++——拷贝构造和重载的赋值运算符
01-20
在C++编程语言中，拷贝构造函数和重载的赋值运算符是两个非常重要的概念，它们都涉及到对象间的复制。这两个概念的理解和正确使用对于编写高效且无内存泄漏的代码至关重要。 **拷贝构造函数（Copy Constructor）** ...
C++——复数——运算符的重载
10-18
对复数进行运算，主要是练习运算符的重载技术。
C++ 类与对象之日期类的创建代码解析
最新发布
02-21
### C++ 类与对象之日期类的创建代码解析 #### 一、背景介绍 在C++编程语言中，面向对象编程(OOP)是一项非常重要的特性，它允许开发者定义自己的数据类型，即类（class），并通过类来创建实例化的对象。本篇文章将...
MyInteger类
11-10
设计一个名为MyInteger的类，类包含： 一个名为valuede 的int型数据域，保存次对象表示的int型值 一个用指定的int型值创建一个MyInteger对象的构造函数 一个返回int型值的获取器函数 函数isEven()、isOdd()和isPrime分别在整数为偶数、奇数或素数的情况下返回真。 静态函数isEven(int)、isOdd（int），和isPrime(int)分别在给定整数为偶数、奇数或素数的情况下返回真。 函数equals（int）和equal（MyInteger）在本对象表示的整数值等于给定值的情况下返回真。 一个静态函数parseInt(string)将一个字符串转换为一个int型值。 画出类的UML图，实现类。编写一个客户程序，测试类的所有函数。
C++ 类，运算符重载--->代码
DeepXL
06-05 521
一个不错的学习文档：      http://www.kuaipan.com.cn/file/id_204066781134907.htm      在线查看： /*mystring.h*/ #include using namespace std; class MyString { friend ostream &operator<<(ostream &,const M
C++ 面向对象(重载运算符和重载函数)
weixin_30729609的博客
05-06 129
C++ 面向对象(重载运算符和重载函数) 转载于:https://www.cnblogs.com/guozepingboke/p/10823065.html
C++类与对象：运算符重载
qq_45481606的博客
07-14 803
什么是运算符重载： C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，有返回值，函数名及参数列表；其返回值类型与参数列表与普通的函数类似。 编译器对于自定义类型的对象，都不支持基本操作符（>,<,++,–）对对象进行操作；只能进行重载 关键字：operator 函数原型：返回值类型 operator操作符(参数列表)，关键字operator后面接需要重载的运算符符号 注意： 不能重载非运算符； 重载操作符函数参数，必须有一个类类型或枚举类...
C++类，重载，构造等
Evildoer_llc的博客
09-23 266
OOP特性：抽象，封装和数据隐藏，多态，继承，代码的可重用性 函数重载（函数多态）：设计一系列的函数完成相同的工作或者说可以使用多个同名的函数 函数重载的关键是：参数列表（函数特征标） 类： class Stock { private: char company[30]; int shares; double share_val; double total_val; void ...
C++(4) 运算符重载
会思考的浣熊的专栏
10-07 758
C++学习心得（1）运算符重载 ——from 谭浩强.C++面向对象程序设计(第一版) 2014/10/6 4.1什么是运算符重载 用户根据C++提供的运算符进行重载，赋予它们新的含义，使之一名多用。 4.2运算符重载的方法 运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。运算符重载实质上是函数的重载。 声明重载运算符+的函数: Complex operator + (Complex &c2); 定义重载运算符+的
C++运算符重载
weixin_46435653的博客
05-15 363
一、运算符重载的定义 对于编译器内置的类型（如int，double）之类的，我们常用的运算符（如“+”，“==”等），是可以自动识别的。但是如果是我们自己定义的类型，编译器并不知道要如何进行操作，如果我们将这个运算符要怎么用告诉编译器，就可以让运算符达到我们想要的操作效果。这个就是运算符重载的定义。 二、运算符重载的语法 这里涉及关键字operator。具体的语法与定义一个函数类似，为： 返回值类型+operator+要重载的运算符+（） 示例： int operator+ (student &st
C++中运算符重载需要遵循的规则
CurryCoder的个人博客
06-05 1535
一.C++中运算符重载需要遵循的规则 1.并不是所有的运算符都可以重载。能够重载的运算符包括： + - * / % ^ & | ~ ! = < > += -= *= /= %= ^= &= |= << >> <<= >>= == != <= >= ...
c++——核心编程
ljinshuo的博客
11-14 1132
核心编程，针对C++面向对象编程技术 1.内存分区模型 内存分区模型 C++程序在执行时，将内存划分为4个区域： 代码区：存放函数体的二进制代码，由操作系统进行管理的。 全局区：存放全局变量、静态变量以及常量。 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等。 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。 内存四区意义： 不同区域存放的数据，赋予不同的生命周期，使编程更加灵活。 1.程序运行前 在程序编译后，生成exe可执行程序，未执行该程序前分为两个区域。 代码区：
C++面向对象设计：运算符重载详解
3. **封装与对象**：C++支持数据封装，这意味着可以隐藏对象内部的细节，只对外提供必要的接口。这与面向对象的封装原则相符，通过类和对象的交互，运算符重载使得对象之间的交互更加自然和直观。 4. **面向对象...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值