C++ explicit、using、::、decltype 等（二）

explicit

• explicit 修饰构造函数时，可以防止隐式转换和复制初始化
• explicit 修饰转换函数时，可以防止隐式转换，但 按语境转换 除外

#include <iostream>

using namespace std;

struct A
{
	A(int) { }
	operator bool() const { return true; }
};
struct B
{
	explicit B(int) {}
	explicit operator bool() const { return true; }
};

void doA(A a) {}

void doB(B b) {}

int main()
{
	A a1(1);		// OK：直接初始化
	A a2 = 1;		// OK：复制初始化
	A a3{ 1 };		// OK：直接列表初始化
	A a4 = { 1 };	// OK：复制列表初始化
	A a5 = (A)1;	// OK：允许 static_cast 的显式转换

	doA(1);			// OK：允许从 int 到 A 的隐式转换
	if (a1);		// OK：使用转换函数 A::operator bool() 的	从 A 到 bool 的隐式转换	
	bool a6(a1);	// OK：使用转换函数 A::operator 	bool() 的从 A 到 bool 的隐式转换
	bool a7 = a1;	// OK：使用转换函数 A::operator 	bool() 的从 A 到 bool 的隐式转换
	bool a8 = static_cast<bool>(a1); // OK ：static_cast 	进行直接初始化


	B b1(1);		// OK：直接初始化
	//B b2 = 1;		// 错误：被 explicit 修饰构造函数的对象不可	以复制初始化
	B b3{ 1 };		// OK：直接列表初始化
	//B b4 = { 1 }; // 错误：被 explicit 修饰构造函数的对象	不可以复制列表初始化
	B b5 = (B)1;	// OK：允许 static_cast 的显式转换
	//doB(1);		// 错误：被 explicit 修饰构造函数的对象不	可以从 int 到 B 的隐式转换
	if (b1);		// OK：被 explicit 修饰转换函数	B::operator bool() 的对象可以从 B 到 bool 的按语境转换
	bool b6(b1);	// OK：被 explicit 修饰转换函数	B::operator bool() 的对象可以从 B 到 bool 的按语境转换
	//bool b7 = b1; // 错误：被 explicit 修饰转换函数	B::operator bool() 的对象不可以隐式转换
	bool b8 = static_cast<bool>(b1); // OK：static_cast 进	行直接初始化
	return 0;
}

using

using 声明 :

一条 using 声明 语句一次只引入命名空间的一个成员。它使得我们可以清楚知道程序中所引用的到底是哪个名字。如：using namespace_name::name;

构造函数的 using 声明 :

在 C++11 中，派生类能够重用其直接基类定义的构造函数。

class Derived : Base {
public:
 using Base::Base;
 /* ... */
};

如上 using 声明，对于基类的每个构造函数，编译器都生成一个与之对应（形参列表完全相同）的派生类构造函数。生成如下类型构造函数：

Derived(parms) : Base(args) { }

using 指示 :

using 指示 使得某个特定命名空间中所有名字都可见，这样我们就无需再为它们添加任何前缀限定符了。如：

using namespace_name name;

尽量少使用 using 指示 污染命名空间
尽量少使用 using 指示

using namespace std;

应该多使用 using 声明

int x;
std::cin >> x ;
std::cout << x << std::endl;

或者

using std::cin;
using std::cout;
using std::endl;
int x;
cin >> x;
cout << x << endl;

:: 范围解析运算符

分类

1. 全局作用域符（::name）：用于类型名称（类、类成员、成员函数、变量等）前，表示作用域为全局命名空间
2. 类作用域符（class::name）：用于表示指定类型的作用域范围是具体某个类的
3. 命名空间作用域符（namespace::name）:用于表示指定类型的作用域范围是具体某个命名空间的

:: 使用

int count = 11; // 全局（::）的 count
class A {
public:
 	static int count; // 类 A 的 count（A::count）
};
int A::count = 21;
void fun()
{
 	int count = 31; // 初始化局部的 count 为 31
 	count = 32; // 设置局部的 count 的值为 32
}
int main() {
 	::count = 12; // 测试 1：设置全局的 count 的值为 12
 	A::count = 22; // 测试 2：设置类 A 的 count 为 22
 	fun(); // 测试 3
 	return 0;
}

decltype

decltype 关键字用于检查实体的声明类型或表达式的类型及值分类。语法：

decltype ( expression )

decltype 使用

// 尾置返回允许我们在参数列表之后声明返回类型
template <typename It>
auto fcn(It beg, It end) -> decltype(*beg)
{
 // 处理序列
 return *beg; // 返回序列中一个元素的引用
}

// 为了使用模板参数成员，必须用 typename
template <typename It>
auto fcn2(It beg, It end) -> typename
remove_reference<decltype(*beg)>::type
{
 // 处理序列
 return *beg; // 返回序列中一个元素的拷贝
}

引用

左值引用

• 常规引用，一般表示对象的身份。

右值引用

• 右值引用就是必须绑定到右值（一个临时对象、将要销毁的对象）的引用，一般表示对象的值。

• 右值引用可实现转移语义（Move Sementics）和精确传递（Perfect Forwarding），它的主要目的有两个方面：

  • 消除两个对象交互时不必要的对象拷贝，节省运算存储资源，提高效率。

  • 能够更简洁明确地定义泛型函数。

引用折叠（？）

引用折叠是为什么出现？要说引用折叠，首先得说右值引用(在看这个之前需要了解C++11中左值，右值的概念)。它是C++11出现的新概念，声明类型的方法是：T&&，具体信息可以看下面的代码：

Class A
{
    A()
    {// do something}
};

A GetA()
{
    return A();
}

int main()
{
    A a1 = GetA();   // a1是左值
    A&& a2 = GetA(); // a2是右值引用
    return 0;
}

a1是左值，在构造时使用了GetA() 产生的临时对象，之后GetA()产生的临时对象会销毁。a2是右值引用，其指向的就是GetA()所产生的对象，这个对象的声明周期是和a2的声明周期是一致的。即少了临时对象，从而省去了临时对象的构造和析构。由此可见右值引用的好处，在新代码中，右值引用是值得大力使用的。但是，在使用的时候，有例外情况了:T&&并不是一定表示右值，比如，如果它绑定的类型是未知的话，既可能是左值，又可能是右值。比如：

template<typename T>
void f(T&& param);

f(10); // 10是右值
int x = 10;
f(x);  // x是左值

以上这种未定的引用类型(param的类型)称为 universal references,这种类型必须被初始化,而它是左值还是右值则取决于它的初始化，如果被左值初始化，那么它就是左值，反之亦然。那么什么时候是左值，什么时候是右值，就需要进行类型推导才知道。
由于存在T&&这种未定的引用类型，当它作为参数时，有可能被一个左值引用或右值引用的参数初始化，这是经过类型推导的T&&类型，相比右值引用(&&)会发生类型的变化，这种变化就称为引用折叠。（《深入应用C++11-代码优化与工程级应用》 — 祁宇 P68 ）
引用折叠的规则如下：

1. 所有右值引用折叠到右值引用上仍然是一个右值引用。（A&& && 变成 A&&）
2. 所有的其他引用类型之间的折叠都将变成左值引用。 （A& & 变成 A&; A& && 变成 A&; A&& & 变成 A&）