C++11 新特性之 Class这是 C++11 新特性介绍的第六部分，涉及到 Class 的相关内容。

前五篇在这里： C++11新特性之新类型与初始化: blog.guoyb.com/2016/06/18/… C++11新特性之类型推断与类型获取: blog.guoyb.com/2016/06/25/… C++11新特性之lambda： blog.guoyb.com/2016/06/30/… C++11新特性之容器相关特性： blog.guoyb.com/2016/07/09/… C++11新特性之智能指针： blog.guoyb.com/2016/08/02/…

这是C++11新特性介绍的第六部分，涉及到Class的相关内容。不想看toy code的读者可以直接拉到文章最后看这部分的总结。

sizeof

新标准中，sizeof可以直接用于获取Class::member的大小，而不用通过Class的实例。

class TestClass
{
public:
	int member_i;
	char member_c;
};

cout<<"test sizeof class member:\n";
cout<


     
default constructor
新标准中，可以通过=default强制编译器生成一个默认constructor。
class TestClass
{
public:
	TestClass() = default;
	TestClass(const int i, const char c): member_i(i), member_c(c) {}

	int member_i;
	char member_c;
};

cout<<"test =default class construct:\n";
TestClass tc; // may cause error if no default construct.
cout<
  
在上面的代码中，如果我们不提供默认constructor的话，无法通过TestClass tc定义一个实例。  
delegate constructor
新标准中，可以在初始化列表中将一个constructor初始化的工作委托给另一个constructor。
class TestClass
{
public:
	TestClass() = default;
	TestClass(const int i, const char c): member_i(i), member_c(c) {}
	TestClass(const int i): TestClass(i, 0) { member_c = 'T';}

	int member_i;
	char member_c;
};

cout<<"test delegating constructor:\n";
TestClass tc2(2);
cout<
  
allocator.construct
新标准中，allocator.construct可以使用任意的构造函数。
class TestClass
{
public:
	TestClass() = default;
	TestClass(const int i, const char c): member_i(i), member_c(c) {}
	TestClass(const int i): TestClass(i, 0) { member_c = 'T';}
	int member_i;
	char member_c;
	};
cout<
allocator alloc;
auto p = alloc.allocate(10);
alloc.construct(p, 10);
cout<member_i<<'\t'<member_c<
  
新标准中，可以通过=default要求编译器合成默认的拷贝/赋值构造函数。
class TestClass
{
public:
	TestClass() = default;
	TestClass(const int i, const char c): member_i(i), member_c(c) {}
	TestClass(const int i): TestClass(i, 0) { member_c = 'T';}
	TestClass(const TestClass&) = default;
	TestClass& operator=(const TestClass&);

	int member_i;
	char member_c;
};

cout<<"test =default class copy construct:\n";
TestClass tc3(tc2);
TestClass tc4 = tc2;
cout<
  
同样，新标准中也允许用=delete禁止拷贝。
class TestClass
{
public:
	TestClass() = default;
	TestClass(const int i, const char c): member_i(i), member_c(c) {}
	TestClass(const int i): TestClass(i, 0) { member_c = 'T';}
	TestClass(const TestClass&) = default;
	TestClass& operator=(const TestClass&);

	int member_i;
	char member_c;
};

cout<<"test =default class copy construct:\n";
TestClass tc3(tc2);
TestClass tc4 = tc2;
cout<
  
override和final
新标准中提供了override和final两个关键字，用于标识子类对父类中虚函数的重写（override）或禁止重写（final）。
class TestClass
{
public:
	TestClass() = default;
	TestClass(const int i, const char c): member_i(i), member_c(c) {}
	TestClass(const int i): TestClass(i, 0) { member_c = 'T';}
	TestClass(const TestClass&) = default;
	TestClass& operator=(const TestClass&);

	virtual void print_msg() {cout<print_msg();
SubTestClass stc(10);
TestClass tc6 = (TestClass)stc;
tc6.print_msg();
  
如果标识了override的函数实际上没有重写父类中的函数，或者标识final的函数被子类重写，编译器都会报错。  
通样的，标识为final的类也不允许作为父类被继承。  
委托父类构造函数
新标准中，也支持子类在初始化列表中直接委托父类的构造函数完成初始化。
class SubTestClass final: public TestClass
{
	public:
		using TestClass::TestClass;
		SubTestClass(const int i): TestClass(i, 'S') {}
		void print_msg() override;
};

cout<<"test inherit base class contructor:\n";
SubTestClass stc2(1024, 'H');
stc2.print_msg();
  
多继承与默认constructor
多重继承的子类可以直接继承父类的构造函数，但是如果父类中有形参列表完全相同的构造函数，则会产生冲突，这时需要子类自己定义一个自己版本的构造函数。
class TestClass2
{
public:
	TestClass2() = default;
	TestClass2(const int i) {}
};

class MultiSubClass: public TestClass, public TestClass2
{
public:
	using TestClass::TestClass;
	using TestClass2::TestClass2;
	// conflicts with version inherited from ‘TestClass’
	MultiSubClass(const int i): TestClass(i) {}
	MultiSubClass() = default;
};

cout<<"test multi inherit constructor:\n";
MultiSubClass mtc(1024);
mtc.print_msg();
return 0;
  
总结

sizeof可以直接用于获取Class::member的大小，而不用通过Class的实例。
可以通过=default强制编译器生成一个默认constructor。
可以在初始化列表中将一个constructor初始化的工作委托给另一个constructor，以及父类的constructor。
allocator.construct可以使用任意的构造函数。 
可以通过=default要求编译器合成默认的拷贝/赋值构造函数，也可以通过=delete禁止拷贝。
新标准中提供了override和final两个关键字，用于标识子类对父类中虚函数的重写（override）或禁止重写（final），编译会对这两种情况进行检查。final还可以用于类的标识，表示禁止继承。
多重继承的子类可以直接继承父类的构造函数，但是如果父类中有形参列表完全相同的构造函数，则会产生冲突，这时需要子类自己定义一个自己版本的构造函数。  

完整代码详见class.cpp  
转载请注明出处： blog.guoyb.com/2016/08/14/…  
欢迎使用微信扫描下方二维码，关注我的微信公众号TechTalking，技术·生活·思考：