C++-Record27—全局函数与成员函数的互相转化

成员函数与全局函数互相转化的示例

成员函数与全局函数互相转化的问题。这个是为之后的操作符重载做的铺垫。

先定义一个类：

class Test
{
public:
	int a;
	int b;

public:
	Test(int a=0, int b=0)
	{
		this->a = a;
		this->b = b;
	}
protected:
private:
};

 然后，想设计一个求加和的函数，这种定义的方式就是全局函数（这里不强调具体的功能，只求编译器能通过就行）：

Test TestAdd(Test &t1, Test &t2)
{
	Test tmp;
	return tmp;
}

需要注意的是，函数的返回类型设置为"Test"是因为所定义的tmp是Test类型的（类其实是一种数据结构）。所以，这个全局函数是可以通过编译器的。

 将这个全局函数转成一个位于Test类里的成员函数，就变成了如下（这个函数实现了加和的功能）：
 

public:
	//t3 = t1.TestAdd(t2);
	Test TestAdd(Test &t2)
	{
		Test tmp(this->a + t2.a, this->b + t2.b);
		return tmp;
	}

	//t1.TestAdd2(t2);
	//返回一个引用 相当于返回自身 
	//返回t1这个元素 this就是&t1
	Test& TestAdd2(Test &t2)
	{
		this->a = this->a + t2.a;
		this->b = this->b + t2.b;
		
		return *this; //把 *(&t1) 又回到了 t1元素
	}

 在主函中的调用：  

void main181()
{
	Test t1(1, 2);
	Test t2(3, 4);

	Test t3 ;

	//全局函数方法
	t3 = TestAdd(t1, t2);
	//成员函数方法
	{
		//先把测试案例写出来
		Test t4 = t1.TestAdd(t2); //匿名对象直接转化成t4
		t4.printT();
		Test t5;
		t5 = t1.TestAdd(t2); //匿名对象 复制 给t5
		t5.printT();
	}


	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

 再说一个，就是函数不仅可以返回元素也可以返回引用，比如：

public:
	//t3 = t1.TestAdd(t2);
	Test TestAdd(Test &t2)
	{
		Test tmp(this->a + t2.a, this->b + t2.b);
		return tmp;
	}

	//t1.TestAdd2(t2);
	//返回一个引用 相当于返回自身 
	//返回t1这个元素 this就是&t1
	Test& TestAdd2(Test &t2)
	{
		this->a = this->a + t2.a;
		this->b = this->b + t2.b;
		
		return *this; //把 *(&t1) 又回到了 t1元素
	}

这样写，就是返回一个引用了，适用于这样的场景的是，输入一个值，然后，将加和结果，都累加到这个值上，最后，将这个值给输出。 

成员函数于全局函数互相转化的规则

        1、把全局函数转化成成员函数，通过this指针隐藏左操作数

                 Test add(Test &t1, Test &t2)  ===》Test add(Test &t2)

        2、把成员函数转换成全局函数，多了一个参数

                 void printAB()  ===》void printAB(Test *pthis)

        3、函数返回元素和返回引用

			Test& add(Test &t2) //*this //函数返回引用
			{
				this->a = this->a + t2.getA();
				this->b = this->b + t2.getB();
				return *this; //*操作让this指针回到元素状态
			} 

			Test add2(Test &t2) //*this //函数返回元素
			{
				//t3是局部变量
				Test t3(this->a+t2.getA(), this->b + t2.getB()) ;
				return t3;
			}

 

总体代码

dm18_面向对象模型_全局函数成员函数.cpp

#include <iostream>
using namespace std;

class Test
{
public:
	int a;
	int b;

public:
	~Test()
	{
		cout<<"a:"<<a<<" b: "<<b;
		cout<<"析构函数自动被调用"<<endl;
	}

public:
	void printT()
	{
		cout<<"a:"<<a<<" b: "<<b<<endl;
	}

public:
	//t3 = t1.TestAdd(t2);
	Test TestAdd(Test &t2)
	{
		Test tmp(this->a + t2.a, this->b + t2.b);
		return tmp;
	}

	//t1.TestAdd2(t2);
	//返回一个引用 相当于返回自身 
	//返回t1这个元素 this就是&t1
	Test& TestAdd2(Test &t2)
	{
		this->a = this->a + t2.a;
		this->b = this->b + t2.b;
		
		return *this; //把 *(&t1) 又回到了 t1元素
	}

public:
	Test(int a=0, int b=0)
	{
		this->a = a;
		this->b = b;
	}
};

//把成员函数 转成 全局函数 多了一个参数
void printT(Test *pT)
{
	cout<<"a:"<<pT->a<<" b: "<<pT->b<<endl;
}

//全局函数的方法 
//全局函数 转成 成员函数  少了一个参数 
Test TestAdd(Test &t1, Test &t2)
{
	Test tmp;
	return tmp;
}

void main()
{
	Test t1(1, 2);
	Test t2(3, 4);

	//t1 = t1 + t2;
	t1.TestAdd2(t2);
	t1.printT();
}

void main181()
{
	Test t1(1, 2);
	Test t2(3, 4);

	Test t3 ;

	//全局函数方法
	t3 = TestAdd(t1, t2);
	//成员函数方法
	{
		//先把测试案例写出来
		Test t4 = t1.TestAdd(t2); //匿名对象直接转化成t4
		t4.printT();
		Test t5;
		t5 = t1.TestAdd(t2); //匿名对象 复制 给t5
		t5.printT();
	}


	cout<<"hello..."<<endl;
	system("pause");
	return ;
}