C++ 类成员函数调用分析：值传递、指针传递和引用传递

本文通过一个简单的 C++ 程序示例，分析了类成员函数的调用方式，包括值传递、指针传递和引用传递，并解释了每种方式对对象的影响。

程序代码:

#include<iostream.h>
class Myclass
{
private:
	int a,b;
public:
	Myclass(int x1=0,int x2=0)
	{
	a=x1;b=x2;
	cout'构造函数被调用！'<<endl;
	}
	~Myclass()
	{
	cout'析构函数被调用！'<<endl;
	}
	Myclass(Myclass &ob)
	{
	a=ob.a;b=ob.b;
	cout'拷贝构造函数被调用！'<<endl;
	}
	void print(void)
	{
	cout'a='<<a'  b='<<b<<endl;
	}
};
void func1(Myclass ob)
{
cout'func1: ';
	ob.print();
}
void func2(Myclass *ob)
{
cout'func2: ';
	ob->print();
}
void func3(Myclass &ob)
{
cout'func3: ';
	ob.print();
}
int main()
{
Myclass ob(10,10);
cout'main: ';ob.print();
cout'调用func1：'<<endl;
func1(ob);
cout'调用func2：'<<endl;
func2(&ob);
cout'调用func3：'<<endl;
func3(ob);
cout'main: ';ob.print();
}

程序分析:

该程序定义了一个 Myclass 类，包含构造函数、析构函数和拷贝构造函数，以及一个 print() 成员函数。同时定义了三个函数 func1、func2 和 func3，分别以值传递、指针传递和引用传递一个 Myclass 对象，并在函数内部调用对象的 print() 成员函数。在主函数中定义了一个 Myclass 对象 ob，并分别以值传递、指针传递和引用传递方式调用三个函数，并在主函数中再次调用 ob 的 print() 成员函数。

程序输出:

构造函数被调用！
main: a=10  b=10
调用func1：
拷贝构造函数被调用！
func1: a=10  b=10
析构函数被调用！
调用func2：
func2: a=10  b=10
调用func3：
func3: a=10  b=10
main: a=10  b=10
析构函数被调用！

分析:

值传递: 在 func1 中，ob 以值传递的方式传递给函数。这意味着，函数内部会创建一个新的 Myclass 对象，并用 ob 的值初始化它。因此，在 func1 内部对 ob 的修改不会影响到主函数中的 ob 对象。当 func1 执行完毕后，新的 Myclass 对象会被销毁，并调用析构函数。
指针传递: 在 func2 中，ob 的地址以指针传递的方式传递给函数。这意味着，函数内部直接使用传入的指针访问主函数中的 ob 对象。因此，在 func2 内部对 ob 的修改会影响到主函数中的 ob 对象。由于 func2 中没有对 ob 进行修改，所以没有调用拷贝构造函数。
引用传递: 在 func3 中，ob 以引用传递的方式传递给函数。这意味着，函数内部直接使用传入的引用访问主函数中的 ob 对象。因此，在 func3 内部对 ob 的修改会影响到主函数中的 ob 对象。由于 func3 中没有对 ob 进行修改，所以没有调用拷贝构造函数。

总结:

值传递: 适用于需要复制对象的情况，但会造成额外开销，特别是对于大型对象。
指针传递: 适用于需要修改对象，但需要手动管理指针。
引用传递: 适用于需要修改对象，且不需要手动管理内存。

通过以上分析，我们可以更好地理解 C++ 中不同成员函数调用方式的特点，并根据实际需要选择合适的调用方式。