在传参和传值返回的过程中，编译器会通过一些优化减少拷贝的次数。

class A
{
public:
	A()
		:_a(1)
	{
		cout << "A()" << endl;
	}

	A(const A& aa)
		:_a(aa._a)
	{
		cout << "A(const A& aa)" << endl;
	}

	A& operator=(const A& aa)
	{
		cout << "A& operator=(const A& aa)" << endl;
		if (this != &aa)
		{
			_a = aa._a;
		}
		return *this;
	}

	~A()
	{
		cout << "~A()" << endl;
	}

private:
	int _a;
};

void f1(A aa)
{
}

A f2()
{
	A a1;
	return a1;
}

场景1：

int main()
{
    // 传值传参
	A a1;
	f1(a1);
	cout << endl;
	// 传值返回
	f2();
	cout << endl;
	return 0;
}

运行结果：

1. 隐式转换，连续构造+拷贝构造——>直接构造：

int main()
{
	f1(1);
	return 0;
}

2. 一个表达式中，连续构造+拷贝构造——>直接构造：

int main()
{
	f1(A(1));
	return 0;
}

3. 一个表达式中，拷贝构造+拷贝构造——>一个拷贝构造：

int main()
{
	A a2 = f2();
	return 0;
}