C++经验（二）--编译器默认生成的函数

我们定义一个空类。编译器会为我们默认生成一些函数。如果我们没有声明，编译器会帮我们生成一个拷贝构造函数、一个拷贝赋值操作符和一个析构函数。同时如果我们声明构造函数的话，也会生成一个默认的构造函数。

class Empty{};

上面我们定义了一个空类 Empty,编译器会帮我们生成下面,也就是说， 我们相当于声明了一个下面的类。

class Empty{
  public:
      Empty(){}
      Empty(const Empty& rhs){...}
      ~Empty(){...}
      Empty& operator=(const Empty& rhs){...}
};

我们以下面这个例子为例说明一下。

#include<iostream>
#include<string>

template<class T>
class TestObject{
public:
	TestObject(std::string& name, const T& val) : name(name), value(val)
	{
	}
	void print() const
	{
		std::cout << name<< " " << value << std::endl;
	}
private: 
	std::string& name;
	T value;
}; 

int main()
{
	std::string s1("zhangsan");
	TestObject<int> d1(s1, 5);
	d1.print();
	
	TestObject<int> d2 = d1;
	d2.print();
 
    TestObject<int> d3(d2);
    d3.print(); 

	return 0;
} 

上面的例子中我们声明了一个类TestObject，同时声明了一个构造函数，而如果我们声明了构造函数，编译器就不会再替我们生成默认构造函数。

并且我们没有声明拷贝赋值操作符，但是通过调用TestObject<int> d2 = d1;发现，还是能够将对象d1，拷贝赋值给对象d2。这就是因为我们在使用的时候，编译器自动帮我们生成了拷贝赋值操作符。

同样的，拷贝构造函数也是编译器在我们调用的时候自动生成。

编译器生成的拷贝赋值操作符函数，在行为上和拷贝构造函数基本一致。但需要注意的一点是，这必须保证其生成的代码合法并且有用的情况下，编译器才会自动生成，否则，会拒绝生成，毕竟，出力不讨好的事谁也不想做。

#include<iostream>
#include<string>

template<class T>
class TestObject{
public:
	TestObject(std::string& name, const T& val) : name(name), value(val)
	{
	}	
//	TestObject& operator=(const TestObject& rhs)
//	{
//		if(this == &rhs)
//		{
//			return *this;
//		}
//
//		this->name = rhs.name;
//
//		return *this;
//	}
	void print() const
	{
		std::cout << name<< " " << value << std::endl;
	}
private: 
	std::string& name;
	const T& value;
}; 

int main()
{
	std::string s1("zhangsan");
	std::string s2("lisi");
	TestObject<int> d1(s1, 5);
	TestObject<int> d2(s2, 15);
	
	d1.print();
	d2.print();
	d1= d2;
	d1.print();
	
	return 0;
} 

上面的例子，我们在类中定义了成员变量name，该成员变量不再是对象，而是 std::string对象的一个引用。在调用d1 = d2之前，d1.name 和 d2.name 都指向一个std::string，并且这两个 std::string 是不同的。

在调用 d1 = d2 之后呢？d1.name 要指向d2.name吗？

如果编译器生成的拷贝赋值操作符将d1.name 指向d2.name 所指的那个string，就会改变引用自身。这在C++中是不允许的，不允许引用改变指向不同的对象，因为引用是对象的别名，并不像指针一样。

所以，C++ 会拒绝编译赋值的代码。编译的时候会报下面的错误。

non-static reference member 'std::string& TestObject<int>::name', can't use default assignment operator

如果想要在包含引用成员的class中支持赋值操作。必须自己定义拷贝赋值操作符。同样的，内涵const成员的class是相同的处理，因为更改const成员是不合法的。

如果将一个base class的 copy assignment操作符声明为private类型，编译器将拒绝为其derived class 生成 copy assignment操作符。因为编译器生成的 copy assignment操作符理论上是可以调用base class的copy assignment操作符的，但实际上不允许。

前面我们所说的，编译器自动帮我们生成的函数，全部都是public并且inline的，但有时候，我们并不希望我们定义的类被拷贝构造、被赋值。这样的情况下，就算我们不声明这些函数，编译器还是会帮我们自动生成，还是会被拷贝构造，还是会被赋值。

要阻止我们定义的类被拷贝构造，被赋值，一个最简单的方法就是我们可以将上面编译器自动帮我们生成的函数声明为private类型。（如果已经声明，编译器不会再自动生成）也就是明确的拒绝了编译器帮我们生成默认的版本。

看似我们已经能够拒绝一些操作了，但是成员函数和friend函数还是能够访问到private函数。除非不去调用这些函数。其实解决这个问题的关键就是，声明函数，但是不定义。如果被member或者friend函数调用该，则会有link-error错误。

上面的第一个例子，如果我们声明它的拷贝构造函数为private类型，并且不定义。

template<class T>
class TestObject{
public:
	TestObject(std::string& name, const T& val) : name(name), value(val)
	{
	}
	void print() const
	{
		std::cout << name<< " " << value << std::endl;
          //TestObject<int> d3(*this);
	}
private:
	TestObject (const TestObject& rhs);
	std::string& name;
	T value;
}; 

int main()
{
	std::string s1("zhangsan");
	TestObject<int> d1(s1, 5);
	d1.print();
	
	TestObject<int> d2 = d1;
	d2.print();

	return 0;
} 

然后进行调用的时候编译器就会报错。

[Error] 'TestObject<T>::TestObject(const TestObject<T>&) [with T = int]' is private

同样的，如果我们在member函数中对对象进行拷贝构造，也会报错。

xxx.cpp:(.text$_ZNK10TestObjectIiE5printEv[_ZNK10TestObjectIiE5printEv]+0x63): undefined reference to `TestObject<int>::TestObject(TestObject<int> const&)'

• 编译器可以自动帮我们生成copy构造、copy assignment操作符、析构、default构造函数
• 如果不希望编译器自动生成上面的这些函数，则可将对应的函数声明为private类型并不定义