重载函数技术推演

最新推荐文章于 2024-07-11 10:18:43 发布

原创最新推荐文章于 2024-07-11 10:18:43 发布 · 387 阅读

CC 4.0 BY-SA版权

#include <iostream>
using namespace std;
//运算符重载使得用户自定义的数据以一种更简洁的方式工作
class Complex
{
public:
	int a;
	int b;
	Complex(int a=0,int b=0)
	{
		this->a=a;
		this->b=b;
	}
	void printCom()
	{
	   cout<<a<<"+"<<b<<"i"<<endl;
	}
protected:
private:
};
Complex ComAdd(Complex &c1,Complex &c2)
{
	Complex temp;
	temp.a=c1.a+c2.a;
	temp.b=c1.b+c2.b;
	return temp;
}
Complex operator+(Complex &c1,Complex &c2)
{
	Complex temp;
	temp.a=c1.a+c2.a;
	temp.b=c1.b+c2.b;
	return temp;
}
void main()
{
	Complex c1(1,2),c2(3,4);
	//c1=c1+c2;//c1 的类型是Complex ,这种类型，是自定义类型。编译器根本不知道如何加，但是c++ 编译器会提供一个机制，让你实现自定义类型加
	//Complex c3=ComAdd(c1,c2);
	//Complex c3=operator+(c1,c2); 
	Complex c3=c1+c2;
	c3.printCom();
	system("pause");
}

友元函数实现操作符重载

#include <iostream>
using namespace std;
//运算符重载使得用户自定义的数据以一种更简洁的方式工作
class Complex
{
private:
	int a;
	int b;
	friend Complex operator+(Complex &c1,Complex &c2);
	
public:
	void printCom()
	{
	   cout<<a<<"+"<<b<<"i"<<endl;
	}
	Complex(int a=0,int b=0)
	{
		this->a=a;
		this->b=b;
	}
protected:

};

Complex operator+(Complex &c1,Complex &c2)
{
	Complex temp;
	temp.a=c1.a+c2.a;
	temp.b=c1.b+c2.b;
	return temp;
}
//1操作符重载，首先是通过函数实现的
void main()
{
	Complex c1(1,2),c2(3,4);
	//c1=c1+c2;//c1 的类型是Complex ,这种类型，是自定义类型。编译器根本不知道如何加，但是c++ 编译器会提供一个机制，让你实现自定义类型加
	//Complex c3=ComAdd(c1,c2);
	//Complex c3=operator+(c1,c2); 
   //2  + 操作符 有两个参数 左操作数和右操作数  
	//3  
	Complex c3=c1+c2;
	c3.printCom();
	system("pause");
}

#include <iostream>
using namespace std;
//运算符重载使得用户自定义的数据以一种更简洁的方式工作
class Complex
{
private:
	int a;
	int b;
	friend Complex operator+(Complex &c1,Complex &c2);
	
public:
	void printCom()
	{
	   cout<<a<<"+"<<b<<"i"<<endl;
	}
	Complex(int a=0,int b=0)
	{
		this->a=a;
		this->b=b;
	}
	//通过类实现-操作
	Complex operator-(Complex &c2)
	{
		Complex tmp;
		tmp.a=this->a-c2.a;
		tmp.b=this->b-c2.b;
		return tmp;
	}
protected:

};

Complex operator+(Complex &c1,Complex &c2)
{
	Complex temp;
	temp.a=c1.a+c2.a;
	temp.b=c1.b+c2.b;
	return temp;
}
//1操作符重载，首先是通过函数实现的
void main()
{
	Complex c1(1,2),c2(3,4);
	//c1=c1+c2;//c1 的类型是Complex ,这种类型，是自定义类型。编译器根本不知道如何加，但是c++ 编译器会提供一个机制，让你实现自定义类型加
	//Complex c3=ComAdd(c1,c2);
	//Complex c3=operator+(c1,c2); 
   //2  + 操作符 有两个参数 左操作数和右操作数  
	//3  
	Complex c3=c1+c2;
	// 通过类的成员函数，完成操作符重载
	//1,要承认操作符号重载是一个函数，要写函数原型
	//2,写出函数调用语言
	   
	  //c1.operator-(c2);
	
	c3.printCom();

	Complex c4=c1-c2;
	c4.printCom();
	system("pause");
}

前置++ --

#include <iostream>
using namespace std;
//运算符重载使得用户自定义的数据以一种更简洁的方式工作
class Complex
{
private:
	int a;
	int b;
	friend Complex operator+(Complex &c1,Complex &c2);
	friend Complex& operator++(Complex &c2);
public:
	void printCom()
	{
	   cout<<a<<"+"<<b<<"i"<<endl;
	}
	Complex(int a=0,int b=0)
	{
		this->a=a;
		this->b=b;
	}
	//通过类实现-操作
	Complex operator-(Complex &c2)
	{
		Complex tmp;
		tmp.a=this->a-c2.a;
		tmp.b=this->b-c2.b;
		return tmp;
	}
	//前置--
	Complex& operator--()
	{
		this->a--;
		this->b--;
	    return *this;
	}
protected:

};
Complex& operator++(Complex &c2)
{
	c2.a++;
	c2.b++;
	return c2;
}
Complex operator+(Complex &c1,Complex &c2)
{
	Complex temp;
	temp.a=c1.a+c2.a;
	temp.b=c1.b+c2.b;
	return temp;
}
//1操作符重载，首先是通过函数实现的
void main()
{
	Complex c1(1,2),c2(3,4);
	//c1=c1+c2;//c1 的类型是Complex ,这种类型，是自定义类型。编译器根本不知道如何加，但是c++ 编译器会提供一个机制，让你实现自定义类型加
	//Complex c3=ComAdd(c1,c2);
	//Complex c3=operator+(c1,c2); 
   //2  + 操作符 有两个参数 左操作数和右操作数  
	//3  
	Complex c3=c1+c2;
	// 通过类的成员函数，完成操作符重载
	//1,要承认操作符号重载是一个函数，要写函数原型
	//2,写出函数调用语言
	   
	  //c1.operator-(c2);
	
//	c3.printCom();

	Complex c4=c1-c2;
	//c4.printCom();
	//Complex& operator++(Complex &c2);
	++c2;
	c2.printCom();
	--c1;
	c1.printCom();
	system("pause");
}