C++运算符重载，匿名对象，三连等

已于 2023-01-16 03:10:18 修改
阅读量1.3k 收藏 2
点赞数
分类专栏： C++核心编程 文章标签： c++ c语言 开发语言
于 2022-12-22 00:48:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37891604/article/details/128357779
版权

，目录

 1、加号运算符重载

1.1 通过自己写成员函数，实现两个对象相加属性后返回新的对象

1.2通过成员函数实现加法运算符重载

1.3通过全局函数实现加法运算符重载，运算符重载也可以发生函数重载

 1.4总结--对于内置的数据类型的表达式运算符是不可以改变的

2.左移运算符

2.1不会利用成员函数重载成员函数

2.2只能利用全局函数重载左移运算符

3.递增运算符重载

 3.1重载前置递增运算符

3.1.1成员函数重载前置递增运算符

 3.1.2利用全局函数重载前置递增运算符

3.2重载后置递增运算符

3.2.1利用成员函数重载后置递增运算符

3.2.2利用全局函数重载后置递增

4.赋值运算符重载

5.关系运算符重载

 5.1利用成员函数重载关系运算符

5.2利用全局函数重载关系运算符

6.函数调用运算符()(小括号)重载，匿名函数对象，匿名对象

 1、加号运算符重载

1.1 通过自己写成员函数，实现两个对象相加属性后返回新的对象

#include<iostream>
using namespace std;

class Person
{
public:
	int m_A;
	int m_B;
	Person PersonAddPerson(Person& p)
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;    
	}
	
	/*第二种写法
	Person & PersonAddPerson(Person& p1, Person& p2)
	{
		this->m_A = p1.m_A + p2.m_A;
		this->m_B = p1.m_B + p2.m_B;
		return *this;
	}
	*/

};
void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;
	Person p3 = p1.PersonAddPerson(p2);
	
	//Person p3;第二种写法的调用
	//p3.PersonAddPerson(p1, p2);

	cout << p3->m_A << " " << p3->m_B << endl;
}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

1.2通过成员函数实现加法运算符重载

#include<iostream>
using namespace std;

//加号运算符重载




class Person
{
public:
	int m_A;
	int m_B;
	//1、成员函数重载+号
	Person operator+(Person& p)//operator+编译器起的函数名
	{
		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 = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	Person p3 = p2.operator+(p1);
	//Person p3 = p1 + p2;//成员函数重载本质调用Person p3=p2.operator+(p1)
	cout << "p3.m_A = "<<p3.m_A << " " <<"p3.m_B = "<< p3.m_B << endl;
}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

1.3通过全局函数实现加法运算符重载，运算符重载也可以发生函数重载

#include<iostream>
using namespace std;

//加号运算符重载




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

//2、全局函数重载+号
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 = 10;
	Person p2;
	p2.m_A = 10;
	p2.m_B = 10;

	//Person p3 = operator+(p1, p2);
	Person p3 = p1 + p2;//全局函数重载本质调用Person p3 = operator+(p1, p2);
	cout << p3.m_A << " " << p3.m_B << endl;
	Person p4 = p1 + 100;
	cout << p4.m_A << " " << p4.m_B << endl;
	//运算符重载 也可以发生函数重载

}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

 1.4总结--对于内置的数据类型的表达式运算符是不可以改变的

对于内置的数据类型的表达式运算符是不可以改变的，比如你把两个整型数据相加的，在函数里面写两数相减，这是不允许的

2.左移运算符

2.1不会利用成员函数重载成员函数

#include<iostream>
using namespace std;

//左移运算符
class Person
{
public:

	//利用成员函数重载 左移运算符
	//p.operator<<(cout) 简化版本p<<cout
	//所以不会利用成员函数重载<<运算符，因为无法实习cout在左侧
	//即cout<<
	void operator<<(cout)
	{
       //但你不知道返回什么就先写void
	}
	int m_A;
	int m_B;

};
void test01()
{
	Person p;
	p.m_A = 10;
	p.m_B = 10;
	cout << p.m_A  << endl;
}




int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

2.2只能利用全局函数重载左移运算符

#include<iostream>
using namespace std;

//左移运算符
class Person
{
public:

	int m_A;
	int m_B;

};


//只能利用全局函数重载左移运算符
void operator<<(ostream& cout, Person& p)//本质 operator<<(cout,p)简化为cout<<p
{
	//cout是输出流对象
	//cout只能有一个，要用引用的方式传递
	cout << "m_A = " << p.m_A << " " << "m_B = " << p.m_B;
}

void test01()
{
	Person p;
	p.m_A = 10;
	p.m_B = 10;
	cout <<p;
	//cout << p << endl;//报错
	// 链式调用
	//是因为cout << p本质 operator<<(cout,p)，返回值为空，当然不能往后追加内容了
	//不能写endl
}


int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}
=
#include<iostream>
using namespace std;

//左移运算符
class Person
{
	//全局函数做Person的好朋友，可以访问Person类的私有成员
	friend ostream& operator<<(ostream& cout, Person& p);
public:
	Person(int a, int b)
	{
		m_A = a;
		m_B = b;
	}

private:

	int m_A;
	int m_B;

};


//只能利用全局函数重载左移运算符
ostream& operator<<(ostream& cout, Person& p)//本质 operator<<(cout,p)简化为cout<<p
{
	//cout是输出流对象
	//cout只能有一个，要用引用的方式传递
    //因为属性私有，所以设为友元
	cout << "m_A = " << p.m_A << " " << "m_B = " << p.m_B;
	return cout;
}
/*
这样也对
ostream& operator<<(ostream& out, Person& p)//本质 operator<<(cout,p)简化为cout<<p
{
	
	out << "m_A = " << p.m_A << " " << "m_B = " << p.m_B;
	return out;
}
*/

void test01()
{
	Person p(10,10);
	//链式编程思想
	cout << p  << endl;
	//cout << p本质 operator<<(cout,p)，返回cout
	//执行cout<<endl endl（在 << 右边）不符合右边的形参（person类）的要求
	//endl不是Person类 所以使用iostream中定义的 <<
	//此时的 << 只是最普通的 << ，而不是运算符重载后的 <<
	cout << p << " hello word" << endl;
}


int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

3.递增运算符重载

 自己写一个整型的数据，实现递增运算

 3.1重载前置递增运算符

3.1.1成员函数重载前置递增运算符

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符
	//当不知道返回什么 就先写void
	MyInteger& operator++()
	{
		//先进性++运算
		m_Num++;
		//再将自身返回
		return *this;//返回自身
		/*
		返回引用是为了一直对一个数据进行递增操作
		因为
		int a=0;
		cout<<++(++a)<<endl;//输出2
		cout<<a<<endl;//输出2
		一直在对a这一个数进行操作

		如果返回值，会创建一个拷贝出来一个副本
		*/

	}
	//重载后置++运算符


private:
	int m_Num;
};

//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}
void test01()
{
	MyInteger myint;
	cout << myint << endl;
	cout << ++(++myint) << endl;
	cout <<myint << endl;
}


int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

 3.1.2利用全局函数重载前置递增运算符

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger &myint);
	friend MyInteger& operator++(MyInteger& myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
private:
	int m_Num;
};

//重载前置++运算符
MyInteger& operator++(MyInteger& myint )
{
	myint.m_Num++;
	return myint;
}


//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger &myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}
void test01()
{
	MyInteger myint;
	cout << ++(++myint) << endl;
	cout << myint << endl;
}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

3.2重载后置递增运算符

3.2.1利用成员函数重载后置递增运算符

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符
	MyInteger& operator++()
	{
		m_Num++;
		return *this;
	}
	//重载后置++运算符
	//同一个作用域下，函数名相同，发生了重载，
	// 函数返回值不可以作为重载条件
	//写个int作为占位参数，必须写int 写double float不好使
	//用于区分前置和后置
	//加了int之后，编译器就会认为这是后置的++运算符重载
	//但是前面讲过占位参数调用时必须填补呀，感觉是程序的规定
	//就是你写了int编译器自己就可以区分了
	MyInteger operator++(int)
	{
		/*
		//先返回结果
		return *this;
		//后 递增
		m_Num++;
		如果写return 那么后面的代码就不执行了
		*/
		//先记录结果
		MyInteger temp = *this;
		//后递增
		m_Num++;
		//最后将记录结果返回
		return temp;
		//如果是后置递增，要返回值
		//返回局部对象引用后面就是非法操作，因为，temp是局部变量
		//局部变量在当前函数执行完后就被释放掉了
	}
	
private:
	int m_Num;
};

//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}

void test02()
{
	MyInteger myint;
	cout << myint++ << endl;
	cout << myint << endl;

	/*
	int a = 0;
	cout << (a++)++ << endl;//报错
	cout << a << endl;
	因为在重载后置运算符时我们返回的是值
	所以（myint++）++是不会对同一个数据操作
	实际上我们看，系统自带的也不支持这种操作
	*/
}


int main()
{
	test02();
	system("pause");//按任意键继续
	return 0;
}

上面的代码我们注意到

 左移运算符，对象是以值传递的方式传入的。那我能不能写成引用呢?答案是可以的

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger &myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符
	MyInteger& operator++()
	{
		m_Num++;
		return *this;
	}
	//重载后置++运算符
	MyInteger operator++(int)
	{
		/*
		//先返回结果
		return *this;
		//后 递增
		m_Num++;
		如果写return 那么后面的代码就不执行了
		*/
		//先记录结果
		MyInteger temp = *this;
		//后递增
		m_Num++;
		//最后将记录结果返回
		return temp;
	}
private:
	int m_Num;
};

//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger &myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}

void test02()
{
	MyInteger myint;
	MyInteger temp = myint++;
	cout << temp << endl;
	cout << myint << endl;
	//这个时候需要写个变量去接受myint++返回的对象
	//如果直接写cout << myint++ << endl;会报错
	//以值的方式返回对象，会调用拷贝构造函数，
	//复制出一个临时副本，感觉应该是这个副本没具体被接收
}


int main()
{
	test02();
	system("pause");//按任意键继续
	return 0;
}

 重载后置++运算符时，返回引用，此时需要用到new

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger &myint);
public:
	MyInteger()
	{
		m_Num = 0;
	}
	//重载前置++运算符
	MyInteger& operator++()
	{
		m_Num++;
		return *this;
	}
	//重载后置++运算符
	MyInteger& operator++(int)
	{
		//也可以直接 new 一个类，然后就可以返回引用了，占用内存还小
		
		//先记录结果
		MyInteger* temp = new MyInteger;
		*temp = *this;
		//后递增
		m_Num++;
		//最后将记录结果返回
		return *temp;
	}
	
private:
	int m_Num;
};

//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger &myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}

void test02()
{
	MyInteger myint;
	cout << myint++ << endl;
	cout << myint << endl;
}


int main()
{
	test02();
	system("pause");//按任意键继续
	return 0;
}

3.2.2利用全局函数重载后置递增

#include<iostream>
using namespace std;

//递增元素符重载

//自定义整型
class MyInteger
{
	friend ostream& operator<<(ostream& cout, MyInteger myint);
	friend MyInteger& operator++(MyInteger& myint);
	friend MyInteger operator++(MyInteger& myint, int);
public:
	MyInteger()
	{
		m_Num = 0;
	}
private:
	int m_Num;
};

//重载前置++运算符
MyInteger& operator++(MyInteger& myint )
{
	myint.m_Num++;
	return myint;
}

//重载后置++运算符
MyInteger operator++(MyInteger& myint,int)
{
	cout << "后置" << endl;
	//先记录结果
	MyInteger temp = myint;
	//后递增
	myint.m_Num++;
	//最后将记录结果返回
	return temp;
}

//重载<<(左移)运算符
ostream& operator<<(ostream& cout, MyInteger myint)
{
	cout << myint.m_Num;//因为私有，所以做友元
	return cout;
}
void test02()
{
	MyInteger myint;
	cout << myint++ << endl;
	cout << myint << endl;
}
int main()
{
	test02();
	system("pause");//按任意键继续
	return 0;
}

4.赋值运算符重载

下面代码 会报错，原因如下面图片所述 

#include<iostream>
using namespace std;

//赋值运算符重载

class Person
{
public:
	Person(int age)
	{
		m_Age=new int(age);//将age数据开辟在堆区
	}
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}
	int* m_Age;//开辟 到堆区
};
void test01()
{
	Person p1(18);

	Person p2(20);

	p2 = p1;//赋值操作
	cout << "p1的年龄为 " << *p1.m_Age<<endl;
	cout << "p2的年龄为 " << *p2.m_Age << endl;
}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

 解决方法

 第一种，自己写个拷贝构造函数将p1赋值给p2

#include<iostream>
using namespace std;

//赋值运算符重载

class Person
{
public:
	Person(int age)
	{
		m_Age=new int(age);//将age数据开辟在堆区
	}
	Person(const Person &p)
	{
		m_Age = new int(*p.m_Age);
	}
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}
	int* m_Age;//开辟 到堆区
};
void test01()
{
	Person p1(18);

	Person p2(p1);

	//赋值操作
	cout << "p1的年龄为 " << *p1.m_Age<<endl;
	cout << "p2的年龄为 " << *p2.m_Age << endl;
}
int main()
{
	test01();
	system("pause");//按任意键继续
	return 0;
}

第二种，重载赋值运算符,必须用成员函数重载赋值运算符

#include<iostream>
using namespace std;

//赋值运算符重载

class Person
{
public:
	Person(int age)
	{
		m_Age=new int(age);//将age数据开辟在堆区
	}
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//重载 赋值运算符
	Person& operator=(Person &p)
	{
		//编译器提共的是浅拷贝
		//m_Age = p.m_Age;

		//应该判断是否有属性在堆区， 如果有先释放干净， 然后在深拷贝
		//将p1的数据给到p2，但是p2已经有一块内存了
		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 p1(18);

	Person p2(20);

	Person p3(30);
    //p2 = p1;//本质上是p2.operator(p1)

	p3=p2 = p1;//赋值操作
	cout << "p1的年龄为 " << *p1.m_Age<<endl;
	cout << "p2的年龄为 " << *p2.m_Age << endl;
	cout << "p3的年龄为 " << *p3.m_Age << endl;
}
int main()
{
	test01();

	/*
	int a = 10,b=20,c=30;
	c = b = a;
	//将a的值赋值给b,此时b为10
	//再将b的值赋值给c,此时c也为10
	cout << "a = " << a << endl;//输出 10
	cout << "b = " << b << endl;//输出 10
	cout << "c = " << c << endl;//输出 10
	*/
	
	system("pause");//按任意键继续
	return 0;
}

#include<iostream>
using namespace std;

//赋值运算符重载

class Person
{
public:
	Person(int age)
	{
		m_Age = new int(age);//将age数据开辟在堆区
	}
	~Person()
	{
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
	}

	//重载 赋值运算符
	Person& operator=( Person &p)
	{
		//编译器提共的是浅拷贝
		//m_Age = p.m_Age;

		//应该判断是否有属性在堆区， 如果有先释放干净， 然后在深拷贝
		//将p1的数据给到p2，但是p2已经有一块内存了
		if (m_Age != NULL)
		{
			delete m_Age;
			m_Age = NULL;
		}
		//深拷贝
		m_Age = new int(*p.m_Age);
		//返回对象本身
		return *this;
		//返回引用才是真正的自身
		
		//不返回void 是因为我们可能会采取a=b=c，如果b=c返回void就没法给a赋了
		//那为什么返回引用呢？
		//如果返回值，即返回类对象会调用拷贝构造函数
		//而我们没给，编译器默认给的是浅拷贝
		//那析构就会带来问题，堆区数据被重复释放
		//如果没有创建在堆区的数据是可以返回值的
		
		// 返回值时不能写a=b=c这种
		// 为什么呢？因为我们写的是(Person &p)
		//b=c时我们返回return *this,返回的是左值，不可以修改，是值
		// 而我们又传入的是引用，报错
		//不理解先看博客
		//https://blog.csdn.net/qq_37891604/article/details/128210998?spm=1001.2014.3001.5501
		//
		//所以想返回值还想实现a=b=c怎么办？
		//Person operator=(const Person & p)
		// 那就将引用改为常量引用
		
		
	}
	int* m_Age;//开辟 到堆区
};
void test01()
{
	Person p1(18);

	Person p2(20);

	Person p3(30);
	//p2 = p1;//本质上是p2.operator(p1)

	p3 = p2 = p1;//赋值操作
	cout << "p1的年龄为 " << *p1.m_Age << endl;
	cout << "p2的年龄为 " << *p2.m_Age << endl;
	cout << "p3的年龄为 " << *p3.m_Age << endl;
}
int main()
{
	test01();

	/*
	int a = 10,b=20,c=30;
	c = b = a;
	//将a的值赋值给b,此时b为10
	//再将b的值赋值给c,此时c也为10
	cout << "a = " << a << endl;//输出 10
	cout << "b = " << b << endl;//输出 10
	cout << "c = " << c << endl;//输出 10
	赋值采用的是右结合律，所以上述连锁赋值被解析为：
    x = (y = (z = 15)); //赋值连锁形式
    这里15先被赋值给z，然后其结果(更新后的z)再被赋值给y，
    然后其结果（更新后的y）再被赋值给x。
	*/

	system("pause");//按任意键继续
	return 0;
}

 

5.关系运算符重载

 

 5.1利用成员函数重载关系运算符

#include<iostream>
using namespace std;

//重载关系运算符
class Person
{
public:
	Person(string name, int age)
	{
		m_Name = name;
		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 true;
		}
		return false;
	}
	string m_Name;
	int m_Age;
};
void test01()
{
	Person p1("Tom", 18);
	Person p2("Tom", 18);
	if (p1 == p2)//本质p1.operator==(p2)
	{
		cout << "p1和p2是相等的" << endl;
	}
	else
	{
		cout << "p1和p2是不相等的" << endl;
	}
	if (p1 != p2)//本质p1.operator==(p2)
	{
		cout << "p1和p2是不相等的" << endl;
	}
	else
	{
		cout << "p1和p2是相等的" << endl;
	}
}
int main()
{
	
	test01();
	system("pause");//按任意键继续
	return 0;
}

5.2利用全局函数重载关系运算符

#include<iostream>
using namespace std;

//重载关系运算符
class Person
{
public:
	Person(string name, int age)
	{
		m_Name = name;
		m_Age = age;
	}

	
	string m_Name;
	int m_Age;
};
//重载==
bool operator==(Person& p1,Person &p2)
{
	if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
	{
		return true;
	}
	return false;
}

//重载!=
bool operator!=(Person& p1, Person& p2)
{
	if (p1.m_Name !=p2.m_Name || p1.m_Age != p2.m_Age)
	{
		return true;
	}
	return false;
}
void test01()
{
	Person p1("Tom", 18);
	Person p2("Jerry", 18);
	if (p1 == p2)//本质operator==(p1,p2)
	{
		cout << "p1和p2是相等的" << endl;
	}
	else
	{
		cout << "p1和p2是不相等的" << endl;
	}
	if (p1 != p2)//本质p1.operator==(p2)
	{
		cout << "p1和p2是不相等的" << endl;
	}
	else
	{
		cout << "p1和p2是相等的" << endl;
	}
}
int main()
{
	
	test01();
	system("pause");//按任意键继续
	return 0;
}

6.函数调用运算符()(小括号)重载，匿名函数对象，匿名对象

#include<iostream>
using namespace std;

//函数调用运算符重载

//打印输出类
class MyPrint
{
public:

	//重载函数调用运算符
	void operator()(string test)
	{
		cout << test << endl;
	}
};
void MyPrint02(string test)
{
	cout << test << endl;
}
void test01()
{
	MyPrint myPrint;
	myPrint("hello word");//很像下面的函数调用
	//由于使用起来非常类似于函数调用，因此称为仿函数
	MyPrint02("xyq");//函数调用
}

//仿函数非常灵活，没有固定的写法

//加法类
class MyAdd
{
public:
	int operator()(int num1, int num2)
	{
		return num1 + num2;
	}
};
void test02()
{
	MyAdd myAdd;
	int ret=myAdd(10,10);
	cout << ret<< myAdd(10, 10) << endl;

	//匿名函数对象
	//因为重载了小括号称为匿名函数对象
	cout << MyAdd()(100, 100) << endl;
	// MyAdd()会创建出来一个匿名对象，通过类名加小括号会创建出来一个匿名对象
	//匿名函数对象有一个特点当前行执行完了立即被释放
	//匿名对象在构造函数分类及调用时讲过
}
int main()
{
	test01();
	test02();
	system("pause");//按任意键继续
	return 0;
}

愈努力俞幸运
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
＜C++＞运算符重载完结，详解赋值，关系，函数调用运算符
微凉秋意的博客
06-13 1394
偷偷厉害 万事接可期待。🎉写在前面 书接上文，这次准备分享C++运算符重载的最后三个，分别是赋值运算符重载、关系运算符重载和函数调用运算符重载，直接用这一篇博客来解决剩下的重载方法；文章里会加入容易踩坑的地方等等，就说这么多，开始正文！🎉目录赋值运算符重载类结构问题的出现具体实现关系运算符重载类结构具体实现调用方法运行效果 函数调用运算符重载类结构具体实现调用方法 匿名对象调用🎉总结 在C++中基本数据类型例如整型，可以实现连续赋值：a=b=c；而我们的对象的成员属性虽...
类的6个默认成员函数：构造函数、析构函数、拷贝构造函数、重载运算符、三/五法则
Jormungand_V的博客
03-18 2341
文章目录构造函数默认构造函数的三种不适用情况第一种第二种第三种 class Date { }; 可以看到，上面那个类没有任何成员，是一个空类，但是它真的什么都没有吗？ 其实一个类在我们不写的情况下，也会生成6个默认的成员函数，分别是：构造函数，析构函数，拷贝构造函数，赋值运算符重载，取地址运算符重载，对const对象取地址运算符的重载 构造函数 构造函数是特殊的成员函数，它的主要功能就是初始化对象。和我们之前c语言中自己实现的init函数类似。但是有一点不同的是，init是在我们创建完后才自己调用，
C++中连等的使用
weixin_53515812的博客
11-15 1612
【代码】C++中连等的使用。
三连击C++
weixin_45856170的博客
04-23 2062
题目描述 将 1,2,…,9 共 9 个数分成三组，分别组成三个三位数，且使这三个三位数的比例是a : b : c，试求出所有满足条件的三个三位数，若无解，输出 No!!!。 输入描述： 三个数，a, b, c。 输出描述： 若干行，每行 3 个数字。按照每行第一个数字升序排列。 示例 1： 输入： 1 2 3 输出： 192 384 576 219 438 657 273 546 819 327 654 981 代码实现 #include <iostream> #include &
C++语法10 变量连续赋值、自增自减
bigbigli的博客
06-15 337
当我们需要将变量的值增加1或者减少1的时候，我们可以利用自增（++）自减运算符（--）来完成这个操作。
C++ 字符串 连等
WIMPs_L的博客
06-11 440
C++语法
[C++程序设计](入门级题解)三连击
LynxPioneer的博客
04-22 2686
题目描述 将1,2,…,9共99个数分成3组，分别组成3个三位数，且使这3个三位数构成1:2:3的比例，试求出所有满足条件的3个三位数。 输入输出格式 输入格式： 没有输入 输出格式： 若干行，每行33个数字。按照每行第11个数字升序排列。 输入输出样例 输入样例#1： 无 输出样例#1： 192 384 576 … … … （输出被和谐了） 下面是代码+题解: #include<cstdi...
C++ 面向对象- -运算符的重载（三）
徐小mu的博客
01-01 481
目录 不同类型数据间的转换 1、标准类型数据间的转换 2、转换构造函数 3、类型转换函数 关于运算符重载的归纳   不同类型数据间的转换 1、标准类型数据间的转换 在以前我们对一个变量初始化或者不同数据间进行运算时，都会涉及到数据类型的转换，只是有显式和隐式的区别。隐式类型转换是编译系统自动完成的，不需要用户干预，例： int i=6; i=7.5+i; 编译系统对 7.5...
C++运算符重载（待补充）
m0_73841830的博客
11-17 205
c++重载运算符
c++顺序表【构造函数、运算符重载、析构函数、增删查改等】
Scenlyf的博客
06-11 2969
在C++中写出构造、析构函数等，实现顺序表的增删查改操作。下面是头文件，类函数的实现。#pragma once typedef int DataType; class SeqList { public: SeqList(); //顺序表只考虑深拷贝 //传统写法 //SeqList(const SeqList& s); //SeqList& operator=(const SeqLis
C++(STL)
dididaifly的博客
05-03 1230
C++的STL相关知识
对象被优化以后才是高效的C++编程
最新发布
GeniusAng的博客
07-04 1117
施磊C++语言高级进阶课程，主要讲解对象的优化
C++:类和对象-运算符重载-加法运算符重载
m0_74198346的博客
04-22 171
运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型。思考：通过自己写一个成员函数，实现两个对象相加属性后返回新的对象。对于内置数据类型：编译器知道如何进行运算。编译器起了一个通用的名称。所以上述代码是错误的。1.通过成员函数重载+2.通过全局变量重载+
c++运算符重载+的三种类型
m0_67695275的博客
05-13 397
C++运算符重载+的三种情况
【C++】运算符重载 ③ ( 二元运算符重载 | 运算符重载步骤 | 全局函数 实现 运算符重载 | 成员函数 实现 运算符重载 | 友元函数 实现 运算符重载 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
10-04 660
一、运算符重载步骤 1、运算符重载步骤说明 2、运算符重载类 3、全局函数 实现 运算符重载 4、成员函数 实现 运算符重载 5、完整代码示例 二、友元函数实现运算符重载 1、友元函数实现运算符重载 2、代码示例 - 友元函数实现运算符重载
C 连等条件
lost607的专栏
04-15 1371
若以连等作为条件，不能用a == b
C++通过匿名对象调用成员函数
清凉简装的博客
05-15 2884
C++ 通过匿名对象调用成员函数 刚开始写第一个 leetcode 程序就看到了之前没见到过的东西。首先，框架定义了一个Solution类，我们把方法写在成员函数twoSum(int,int)内，main()函数直接通过构造一个匿名的对象调用该成员函数。 vector<int> ret = Solution().twoSum(nums, target); 进一步总结，如果想要调...
C语言之三联符
lenchio的专栏
03-05 2671
考察如下 C 程序: ??=include int main()?? 你可能看着会觉得很奇怪, 然而这却是一段合法的 C 程序, 我在 vc2008 中尝试编译并成功. 实际上, 三联符序列就是以 ?? 开头的三个字符, 用来对某个其它字符进行指定替换, 替换规则如下表: 三联符 替换 ??= # ??/ \ ??’ ^
c++学习笔记之递增运算符重载
weixin_43699365的博客
08-09 376
目录 递增运算符重载 局部函数前置++重载 全局函数前置++重载 局部函数后置++重载 全部练习代码示例： 递增运算符重载 作用：通过重载递增运算符，实现自己的整形数据 局部函数前置++重载 示例： //前置++，局部函数写法 //返回值注意是引用类型的，这样就是始终对一个数据进行操作，如果把&去掉，每次返回的都是一个新的 Preson& operator++() ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值