C++基础教程面向对象（学习笔记（30））

复制初始化

考虑以下代码行：

int x = 5;

此语句使用拷贝初始化将新创建的整数变量x初始化为值5。

但是，类更复杂一些，因为它们使用构造函数进行初始化。本课将介绍与类的拷贝初始化相关的主题。

拷贝类的初始化

鉴于我们的Fraction类：

#include <cassert>
#include <iostream>
class Fraction
{
private:
    int m_numerator;
    int m_denominator;
 
public:
    // 默认构造函数
    Fraction(int numerator=0, int denominator=1) :
        m_numerator(numerator), m_denominator(denominator)
    {
        assert(denominator != 0);
    }
 
    friend std::ostream& operator<<(std::ostream& out, const Fraction &f1);
};
 
std::ostream& operator<<(std::ostream& out, const Fraction &f1)
{
	out << f1.m_numerator << "/" << f1.m_denominator;
	return out;
}

考虑以下：

int main()
{
    Fraction six = Fraction(6); 
    std::cout << six;
    return 0;
}

如果你要编译并运行它，你会发现它产生了预期的输出：
6/1
这种形式的复制初始化的评估方式与以下相同：

Fraction six(Fraction(6));

正如您在上一课中所了解到的，这可能会调用Fraction（int，int）和Fraction拷贝构造函数（由于性能原因可能会被省略）。但是，由于不能保证删除，最好避免类的拷贝初始化，而是使用直接或统一初始化。

规则：避免使用复制初始化，而是使用统一初始化。

其他地方使用拷贝初始化

还有一些其他地方使用了拷贝初始化，但其中两个值得明确提及。按值传递或返回类时，该进程使用复制初始化。

考虑：

#include <cassert>
#include <iostream>
 
class Fraction
{
private:
	int m_numerator;
	int m_denominator;
 
public:
    //默认构造函数
    Fraction(int numerator=0, int denominator=1) :
        m_numerator(numerator), m_denominator(denominator)
    {
        assert(denominator != 0);
    }
 
        // 拷贝构造函数
	Fraction(const Fraction &copy) :
		m_numerator(copy.m_numerator), m_denominator(copy.m_denominator)
	{
		// 这里不需要检查0的分母，因为副本必须已经是有效的分数
		std::cout << "Copy constructor called\n"; // just to prove it works
	}
 
	friend std::ostream& operator<<(std::ostream& out, const Fraction &f1);
        int getNumerator() { return m_numerator; }
        void setNumerator(int numerator) { m_numerator = numerator; }
};
 
std::ostream& operator<<(std::ostream& out, const Fraction &f1)
{
	out << f1.m_numerator << "/" << f1.m_denominator;
	return out;
}
 
Fraction makeNegative(Fraction f) // 理想情况下我们应该通过const引用来做到这一点
{
    f.setNumerator(-f.getNumerator());
    return f;
}
 
int main()
{
    Fraction fiveThirds(5, 3);
    std::cout << makeNegative(fiveThirds);
 
    return 0;
}

在上面的程序中，函数makeNegative按值获取分数，并返回按值分数。当我们运行这个程序时，我们得到：
Copy constructor called
Copy constructor called
-5/3
当fiveThirds作为参数传递给makeNegative（）参数f时，会发生第一个拷贝构造函数调用。当makeNegative（）的返回值传递回main（）时，会发生第二次调用。

在上面的例子中，不能省略通过值传递的参数和返回值。但是，在其他情况下，如果参数或返回值满足特定条件，编译器可能会选择忽略拷贝构造函数。例如：

class Something
{
};
 
Something foo() 
{
  Something s;
  return s;
}
 
int main()
{
  Something s = foo();
}

在这种情况下，编译器可能会忽略拷贝构造函数，即使变量s是按值返回的。