C++基础知识梳理 2019.1.14（重载 +，重载 左移，++i 和 i++的重载，指针运算符重载（智能指针），赋值运算符重载（拷贝赋值函数），重载（），重载==和！=，自定义字符串类型）

最新推荐文章于 2022-07-18 12:00:00 发布
最新推荐文章于 2022-07-18 12:00:00 发布
阅读量267 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29996285/article/details/86479146
版权

运算符重载

 

重载 +

 

成员函数实现+重载

#include <iostream>
using namespace std;

class Person {
public:
	Person() {};
	Person(int i) :age(i) {};

	Person operator+(const Person&p) {
		Person temp;
		temp.age = this->age + p.age;
		return temp;
	}
private:
	int age;
};

int main() {
	Person p1(5), p2(10);
	Person p3;
	p3=p1 + p2;

	return 0;
}

 

全局函数实现 + 重载

#include <iostream>
using namespace std;

class Person {
public:
	Person() {};
	Person(int i) :age(i) {};

	int age;
};

Person operator+(const Person&p1,const Person&p2) {
	Person temp;
	temp.age = p1.age + p2.age;
	return temp;
}

int main() {
	Person p1(5), p2(10);
	Person p3;
	p3=p1 + p2;

	return 0;
}

 

 

 

重载 <<

<<重载不可以写成成员函数，因为调用成员函数，需要如下那么使用，不符合常规。

 

全局函数重载 <<

#include <iostream>
using namespace std;

class Person {
public:
	Person() {};
	Person(int i) :age(i) {};
private:
	int age;
	friend ostream& operator<<(ostream&cout, Person &p1);
};

ostream& operator<<(ostream&cout, Person &p1) {
	cout << p1.age ;
}

int main() {
	Person p1(5);
	
	cout << p1 <<endl;
	return 0;
}

 

 

++i 和 i++的重载

后置的时候用占位参数来区分前置和后置

void operator++() {

}
//后置的时候用占位参数来区分前置和后置
void operator++(int) {

}

 

前置++部分完成

#include <iostream>
using namespace std;

class MyInt {
public:
	MyInt(int i=0):num(i) {}

	MyInt& operator++() {
		this->num++;
		return *this;
	}
	//后置的时候用占位参数来区分前置和后置
	void operator++(int) {

	}

	int num;
};

ostream& operator<<(ostream& cout, MyInt &myInt) {
	cout << myInt.num;
	return cout;
}

int main() {
	MyInt myInt;
	cout << ++myInt << endl;
	//myInt++;


	return 0;
}

 

完整版

上面的版本的重载<<有一点问题，

需要把第二个参数前面加个const，目测是高版本的g++提升了安全性，视频里面不加const也能通过，但是我就是过不去，在visual studio里面也不报什么有价值的错，还是用g++发现了需要改进的问题。

 

#include <iostream>
using namespace std;

class MyInt {
public:
	MyInt(int i=0):num(i) {}

	MyInt& operator++() {
		this->num++;
		return *this;
	}
	//后置的时候用占位参数来区分前置和后置
	MyInt operator++(int) {
		//先保存目前的数据
		MyInt temp = *this;
		this->num++;
		return temp;
	}

	int num;
};

ostream& operator<<(ostream& cout, const MyInt &myInt) {
	cout << myInt.num;
	return cout;
}

int main() {
	MyInt myInt;
	cout << ++myInt << endl;
	
	cout << myInt++<<endl;
	cout << myInt << endl;

	return 0;
}

 

为什么一个返回值，一个返回引用？

对于一个int变量

	int a = 10;
	cout << ++(++a) << endl;

返回的结果是12，如果两个都是返回值，则

	MyInt myInt;
	cout << ++(++myInt) << endl;

的运行结果是2（初始值是0），但是

cout << myInt << endl;

的值是1.因为第一次++myInt，我们得到的是一个临时变量，因此，第二次的++操作是对这个临时变量进行的操作，并没有改变myInt的值。因此，前置++的返回值是一个引用。

 

 

指针运算符重载（智能指针）

智能指针——用来托管自定义类型对象，让在堆上创建的自定义对象可以自动释放

通过写一个智能指针类，通过智能指针类来创建自定义类的对象。在栈上创建智能指针对象，这样，智能指针对象被释放的时候，就把利用智能指针在堆上创建的自定义对象给一并析构了。

为了让智能指针和指向自定义类类型指针的功能一样，需要重载->和*.

 

智能指针类的例子如下：

//智能指针
//用来托管自定义类型的对象，让对象进行自动的释放
class smartPointer{
public:
	smartPointer(Person * person){
		this->person = person;
	}
	//重载->让智能指针对象 像Person *p一样去使用
	Person * operator->(){
		return this->person;
	}
	//重载 * 
	Person& operator*(){		
		return *this->person;
	}
	~smartPointer(){
		cout << "智能指针析构了" << endl;
        //析构通过智能指针在堆上创建的自定义类的对象
		if (this->person !=NULL){
			delete this->person;
			this->person = NULL;
		}
	}

private:
    //自动以类 Person
	Person * person;
};

整体实现代码

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

class Person{
public:
	Person(int age){
		this->m_Age = age;
	}
	void showAge(){
		cout << "年龄为：" << this->m_Age << endl;
	}
	~Person(){
		cout << "Person的析构调用" << endl;
	}
	int m_Age;
};


//智能指针
//用来托管自定义类型的对象，让对象进行自动的释放
class smartPointer{
public:
	smartPointer(Person * person){
		this->person = person;
	}
	//重载->让智能指针对象 想Person *p一样去使用
	Person * operator->(){
		return this->person;
	}
	//重载 * 
	Person& operator*(){		
		return *this->person;
	}
	~smartPointer(){
		cout << "智能指针析构了" << endl;
		if (this->person !=NULL){
			delete this->person;
			this->person = NULL;
		}
	}

private:
	Person * person;
};

void test01(){
	//sp开辟到了栈上，自动释放，sp就是智能指针了
	smartPointer sp(new Person(10)); 
	// sp->->showAge(); 编译器优化了 写法
	sp->showAge(); 
	(*sp).showAge();
}


int main(){

	test01();
	system("pause");
	return EXIT_SUCCESS;
}

 

 

 

赋值运算符重载（拷贝赋值函数）

系统自动生成的拷贝赋值函数是浅拷贝。下面代码就是一个深拷贝的例子（写的不够严谨）

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//一个类默认创建 默认构造、析构、拷贝构造 operator=赋值运算符 进行简单的值传递
class Person{
public:
	Person(int a){
		this->m_A = a;
	}

	int m_A;
};

void test01()
{
	Person p1(10);
	Person p2(0);
	p2 = p1; //赋值
	cout << "p2 的m_A" << p2.m_A <<endl;
}


class Person2{
public:
	Person2(char * name){
		this->pName = new char[strlen(name) + 1];
		strcpy(this->pName, name);
	}

	//重载 = 赋值运算符
	Person2& operator= ( const Person2 & p){
		//判断如果原来已经堆区有内容，先释放
		if (this->pName != NULL){
			delete[] this->pName;
			this->pName = NULL;
		}
		this->pName = new char[strlen(p.pName) + 1];
		strcpy(this->pName, p.pName);
		return *this;
	}

	~Person2(){
		if (this->pName != NULL){
			delete[] this->pName;
			this->pName = NULL;
		}
	}

	char * pName; 
};

void test02(){
	Person2 p1("狗蛋");
	Person2 p2("狗剩");
	Person2 p3("");
	p3 = p2 = p1;

	cout << p2.pName << endl;
	cout << p3.pName << endl;

}

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

 

 

重载==和!=

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

//  == 
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;
		}
		return false;
	}

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

public:

	string m_Name;
	int m_Age;
};

void test01()
{
	Person p1("小明", 10);
	Person p2("小强", 15);
	Person p3("小强", 15);

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

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

	if (p1 != p2){
		cout << "p1 和 p2 不相等" << endl;
	}else{
		cout << "p1 和 p2 相等" << endl;
	}
}

int main(){

	test01();
	system("pause");
	return EXIT_SUCCESS;
}

 

 

 

重载()

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

// ()重载
class MyPrint{
public:
	void operator()( string text)
		cout << text << endl;
	}
};

void test01(){
	MyPrint myPrint;
	myPrint("hello world1111"); // 仿函数
}

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

void test02(){
	MyAdd myAdd;
	cout << myAdd(1, 1) << endl;
	cout << MyAdd()(1, 1) << endl; //匿名对象
}


int main(){
	test01();
	test02();

	system("pause");
	return EXIT_SUCCESS;
}

 

 

 

自定义字符串类型

 

MyString.h

#pragma  once
#ifndef _CRT_SECURE_NO_WARNINGS
#define  _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;

class MyString{
public:
	MyString(const char * str);
	MyString(const MyString & str);

	~MyString();

	//重载=运算符
	MyString& operator = (const char * str);
	MyString& operator=(const MyString & str);
	
	//重载[]运算符
	char& operator[](int index);

	//重载 +运算符
	MyString operator+(const char * str);
	MyString operator+(const MyString& str);

	//重载 == 运算符
	bool operator==(const char * str);
	bool operator==(const MyString & str);


private:
	char * pString; //执行堆区的指针
	int m_Size; // 字符串大小

	friend ostream& operator<< (ostream& cout, const MyString & str);
	friend istream& operator>> (istream& cin, const MyString & str);

};
#endif

 

MyString.cpp

#include "MyString.h"

ostream& operator<< (ostream& cout, const MyString & str){
	cout << str.pString;
	return cout;
}

//右移运算符重载
istream& operator>> (istream& cin, const MyString & str){
	//先判断 原始是否有内容，如果有 清空
	if (str.pString != NULL){
		delete [] str.pString;
		str.pString = NULL;
	}

	//让用户输入内容
	char buf[1024];
	cin >> buf;

	//把用户输入的字符串 赋值给 str
	str.pString = new char[strlen(buf) + 1];
	strcpy(str.pString, buf);
	str.m_Size = strlen(buf);
	return cin;
}

MyString::MyString(const char * str){
	cout << "有参构造调用" << endl;
	this->pString = new char[strlen(str) + 1];
	strcpy(this->pString, str);
	this->m_Size = strlen(str);
}

MyString::MyString(const MyString & str){
	this->pString = new char[strlen(str.pString) + 1];
	strcpy(this->pString, str.pString);
	this->m_Size = str.m_Size;
}

MyString::~MyString(){
	cout << "析构函数调用" << endl;
	if (this->pString != NULL){
		delete[] this->pString;
		this->pString = NULL;
	}
}

char& MyString::operator[](int index){
	return this->pString[index];
}

MyString& MyString::operator=(const char * str){
	if (this->pString!=NULL){
		delete[] this->pString;
		this->pString = NULL;
	}

	this->pString = new char[strlen(str) + 1];
	strcpy(this->pString, str);

	return *this;
}

MyString& MyString::operator=(const MyString & str){
	if (this->pString != NULL){
		delete[] this->pString;
		this->pString = NULL;
	}

	this->pString = new char[strlen(str.pString) + 1];
	strcpy(this->pString, str.pString);

	return *this;
}

MyString MyString::operator+(const char * str){
	//计算返回的字符串开辟的大小
	int newSize = this->m_Size + strlen(str) + 1;
	char * tmp = new char[newSize];
	memset(tmp, 0, newSize);

	//拼接字符串
	strcat(tmp, this->pString);
	strcat(tmp, str);

	MyString newStr(tmp);
	delete[] tmp;
	return newStr;
}

MyString MyString::operator+(const MyString& str){

	int newSize = this->m_Size + strlen(str.pString) + 1;
	char * tmp = new char[newSize];
	memset(tmp, 0, newSize);

	//拼接字符串
	strcat(tmp, this->pString);
	strcat(tmp, str.pString);

	MyString newStr(tmp);
	delete[] tmp;
	return newStr;
}

bool MyString::operator==(const char * str){
	if ( strcmp( this->pString , str) == 0  
		&& this->m_Size == strlen(str) ){
		return true;
	}
	return false;			
}


bool MyString::operator==(const MyString & str){
	if (strcmp(this->pString, str.pString) == 0 
		&& this->m_Size == strlen(str.pString)){
		return true;
	}
	return false;
}

 

main.cpp

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include "MyString.h"
using namespace std;

//测试 MyString
void test01(){
	MyString str = "abc";
	cout << str << endl;

	cout << "请输入str新的内容：" << endl;
	cin >> str;
	cout << "新内容为：" << str << endl;

	MyString str2(str);
	MyString str3 = "aaaaaa";

	str3 = str2;
	str3 = "aaaa";
	cout << "str3 = " << str3 << endl;

	str3[0] = 'w';
	cout << "str3 第一个位置为 = " << str3[0] << endl;

	MyString str4 = "";
	str4 = str2 + str3; //字符串拼接
	cout << "str4 为 " << str4 << endl;

	if (str3 == str4){
		cout << "str3 与 str4相等" << endl;
	}else{
		cout << "str3 与 str4不相等" << endl;
	}
}

int main(){

	test01();
	system("pause");
	return EXIT_SUCCESS;
}

 

王小闹儿
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++运算符重载基础知识详解
01-20
C++允许将运算符重载扩展到用户定义的类型。例如，允许使用+将两个对象相加。编译器将根据操作数的数目和类型决定使用加法定义。运算符重载可以使代码看起来更自然。例如，将2个数组相加是一种常见的运算。通常，...
libstdc++.so.6.0.25
05-23
libstdc++ 6.0.25版本的库文件,可解决/usr/lib/x86_64-linux-gnu/libstdc++.so.6: version `GLIBCXX_3.4.22' not found版本过低问题。 下载下来后，进入/usr/lib/x86_64-linux-gnu/，删除旧的libstdc++.so.6软连接，...
c++重载运算符_终于搞明白++i/i++的区别|单目运算符重载为成员函数
weixin_39653320的博客
11-24 378
平时++/--这两个单目运算符基本都会用在for循环，之前理解他们的区别只是：1、++i：先++，再循环2、i++：先循环，再++其实，这种说话是有道理的，但是很模糊，直到学到<单目运算符重载为成员函数>的时候，我才真正的搞明白，不禁感叹：C++机制 ！！！举个完整的例子 ：《将前置++和后置++重载为时钟类的成员函数》.hpp文件：```#ifndef ________hpp ``...
1.8 C++基础知识_运算符重载_成员函数
一个嵌入式软件工程师的博客
07-18 172
上一节重载的运算符都是在类外面实现，并且是类的友员，这节尝试在类里面实现运算符重载。
十五. C++运算符重载
ouyangyiwen的博客
12-29 176
目录 运算符重载概念 语法： 重载+友元 常用运算符重载 加号运算符重载 前置后置自增（++）运算符重载 前置++运算符重载 后置++运算符重载 左移运算符（<<）重载 指针运算符重载 赋值运算符重载 关系运算符重载 函数调用运算符重载 运算符重载概念 在c++中，可以定义一个处理类的新运算符。这种定义很像一个普通的函数定义，只是函数的名字由关键字operator及其紧跟的运算符组成。差别仅此而已。它像任何其他函数一样也是一个函数，当编译器遇到适当的模式时，就会调用
重载左移运算符——C++（28）
weixin_44108747的博客
03-02 1606
左移运算符重载 重载左移运算符也属于运算符的重载，不过语法有所不同。 下面是一个 operate << () 函数声明的原型： std::ostream& operator << (std::ostream& os, Fenshu in); 第一个数参数os是将要写入的流，它是以“引用传递”的方式传递的。 第二个参数是打算写到那个流里面...
04_c++重载_指针_引用
u010001130的博客
12-13 376
c++重载/指针/引用
opreator-override.zip_override+c++_运算符重载
09-24
C++运算符重载，主要是为了帮助新人更好地理解C++的运算符重载功能。
c++ 运算符重载和方法重载
01-08
字符串相关操作： strcpy（s1，s2）复制s2为s1； strcmp（s1，s2）比较s1和s2字符串内容是否相同 strcat（s1，s2）拼接字符串，把s2拼接在s1的末尾 strchr（s1，ch）找到s1这个字符...const修饰的取地址运算符重载 析构
C++ 中重载 + 操作符的正确方法
07-26
本文给大家分享了C++ 中重载 + 操作符的正确方法。
c++重载i++与++i；重载i--与--i；即operator++()与operator++(int)；递增++递减--运算符重载
多丰富下自己呀
05-07 1606
目录前言一、理解二、实现总 结参考 前言 递增运算符（ ++ ）和递减运算符（ – ）是 C++ 语言中两个重要的一元运算符。 其实觉得设计的有点鸡肋。。。 一、理解 首先 i++是不能对其取地址的。 因为i++返回的是一个右值。关于左值右值可以看看：–左值与右值– 理解为++i 操作完返回了i 的引用。而i++操作完返回的是操作之前的临时变量。 二、实现 最简单的实现，实验调用机制： int 在 括号内是为了向编译器说明这是一个后缀形式，而不是表示整数。 class fake_int { void
（转）前置++和后置++的区别
balingybj的博客
09-08 999
今天在阅读《google c++ 编程风格》的文档的时候，5.10. 前置自增和自减：有一句话引起了我的注意： 对于迭代器和其他模板对象使用前缀形式 (++i) 的自增, 自减运算符.，理由是 前置自增 (++i) 通常要比后置自增 (i++) 效率更高。于是我查了查前置++和后置++的区别。 注意：《more effective c++》条款8也专门叙述了问题。后来我发现，下面的文章基本就是
i++ 和 ++i 效率的分析以及自定义类型的自增/自减运算符重载实例
leo115的专栏
10-23 4221
我们通常在写for循环 的时候，要实现变量 i 的自增 1 ；往往会在i++ 和++i中随便挑一种写，对于i++和++i的理解，我们往往停留在返回的值的不同，其实i++与++i在实现效率上也有一定的不同(不考虑编译器优化的原因)。 ++i的实现效率更高 解释如下： i++ (在C++中) 在实现的时候，系统会产生一个 local object class INT的临时变量 用于存储原有的数据
i++ 和++i效率和重载问题
u011878387的专栏
09-15 1065
C++中++操作符重载问题 检举|2011-05-19 06:26st_caonima5 | 分类：C/C++ | 浏览312次 （1） CDate& operator ++ () CDate& operator ++ () {AddDays (1); return *this;} （2） CDate ope
c++ 重载 重写_关于C/C++中的++i和i++实现机制的探讨
weixin_36327991的博客
12-21 394
最近遇到了一个比较有意思的代码：int main(){ int i = 0; i = i++; //问如果打印i的值，结果是多少？ return 0;}这个问题实际上涉及到了前置及后置操作符的内部实现问题。下面我们通过模仿前置和后置操作符的实现方式，来加深对前置、后置操作符实现原理的理解：首先，我们使用类MyInt来模拟整型：class MyInt{public:...
c++中重载+=运算符值不改变的问题
CoAAColA的博客
06-04 450
背景：今天在使用pair<int,int>时，想重载它的+=运算符，写成了如下形式： pair<int,int> operator += (pair<int,int> a, pair<int,int> b) { return make_pair(a.first+b.first,a.second+b.second); } 结果发现在进行+=操作后，+=的左值并没有发生改变， 转念一想，使用操作符实际上可以理解为一次函数的调用，因此，我想得到的值作为
pd16.py11111111111
最新发布
06-02
pd16.py11111111111
u-boot-2024.07-rc3.tar.bz2
06-02
【U-Boot 2024.07源码深度解析】002 - 下载及编译 U-Boot 源码 https://blog.csdn.net/Ciellee/article/details/139381921 配套的资源
287_基于移动端选课系统的设计与实现-源码.zip
06-02
提供的源码资源涵盖了安卓应用、小程序、Python应用和Java应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。
c++运算符重载前置++和后置++的区别
05-20
重载前置++和后置++的区别在于返回值和参数。 重载前置++需要返回递增后的对象本身，因为前置++操作是在对象递增之后再使用对象的值。而重载后置++需要返回递增之前的对象值，因为后置++操作是在对象递增之前使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值