C++11特性：使用using和typedef给模板定义别名

在 C++中可以通过 typedef 重定义一个类型，语法格式如下：

typedef 旧的类型名 新的类型名;
// 使用举例
typedef unsigned int uint_t;

被重定义的类型并不是一个新的类型，仅仅只是原有的类型取了一个新的名字。和以前的声明语句一样，这里的声明符也可以包含类型修饰，从而也能由基本数据类型构造出复合类型来。C++11中规定了一种新的方法，使用别名声明(alias declaration)来定义类型的别名，即使用using。

在使用的时候，关键字using作为别名声明的开始，其后紧跟别名和等号，其作用是把等号左侧的名字规定成等号右侧类型的别名。类型别名和类型的名字等价，只要是类型的名字能出现的地方，就能使用类型别名。使用typedef定义的别名和使用using定义的别名在语义上是等效的。

使用using定义别名的语法格式是这样的：

using 新的类型 = 旧的类型;
// 使用举例
using uint_t = int;

?使用typedef无法重定义一个模板，如果要使用typedef重定义一个模板，则需要添加一个外敷类。

template<typename T>
struct MyMap
{
	typedef map<int, T> mapType;
};

#include<iostream>
#include<map>
using namespace std;

//类模板方便遍历不同类型的容器
template<class T>
class Container
{
public:
	void print(T& t)
	{
		auto it = t.begin();
		for (; it != t.end(); ++it)
		{
			cout << it->first << " " << it->second << '\n';
		}
	}
};

template<typename T>
struct MyMap
{
	typedef map<int, T> mapType;
};


int main()
{
	cout << "typedef:" << '\n';
	MyMap<int>::mapType mm1;
	mm1.insert(make_pair(1, 1));
	mm1.insert(make_pair(2, 2));
	mm1.insert(make_pair(3, 3));
	Container<MyMap<int>::mapType> c1;
	c1.print(mm1);

	MyMap<double>::mapType mm2;
	mm2.insert(make_pair(1, 1.1));
	mm2.insert(make_pair(2, 2.2));
	mm2.insert(make_pair(3, 3.3));
	Container<MyMap<double>::mapType> c2;
	c2.print(mm2);

	MyMap<string>::mapType mm3;
	mm3.insert(make_pair(1, "one"));
	mm3.insert(make_pair(2, "two"));
	mm3.insert(make_pair(3, "three"));
	Container<MyMap<string>::mapType> c3;
	c3.print(mm3);

	

	return 0;
}

使用外敷类加typedef的运行结果为：

?

虽然可以达到我们想要的效果，但是看起来太麻烦了。所以推荐使用using来给模板起别名。

template<typename T>
using MMap = map<int, T>;

两种方法的运行结果是一致的。?

#include<iostream>
#include<map>
using namespace std;

template<class T>
class Container
{
public:
	void print(T& t)
	{
		auto it = t.begin();
		for (; it != t.end(); ++it)
		{
			cout << it->first << " " << it->second << '\n';
		}
	}
};

template<typename T>
struct MyMap
{
	typedef map<int, T> mapType;
};

template<typename T>
using MMap = map<int, T>;

int main()
{
	cout << "typedef:" << '\n';
	MyMap<int>::mapType mm1;
	mm1.insert(make_pair(1, 1));
	mm1.insert(make_pair(2, 2));
	mm1.insert(make_pair(3, 3));
	Container<MyMap<int>::mapType> c1;
	c1.print(mm1);

	MyMap<double>::mapType mm2;
	mm2.insert(make_pair(1, 1.1));
	mm2.insert(make_pair(2, 2.2));
	mm2.insert(make_pair(3, 3.3));
	Container<MyMap<double>::mapType> c2;
	c2.print(mm2);

	MyMap<string>::mapType mm3;
	mm3.insert(make_pair(1, "one"));
	mm3.insert(make_pair(2, "two"));
	mm3.insert(make_pair(3, "three"));
	Container<MyMap<string>::mapType> c3;
	c3.print(mm3);

	cout << "------------------------\nusing:\n";
	MMap<int> um1;
	um1.insert(make_pair(1, 1));
	um1.insert(make_pair(2, 2));
	um1.insert(make_pair(3, 3));
	Container<MMap<int>> uc1;
	uc1.print(um1);

	MMap<double> um2;
	um2.insert(make_pair(1, 1));
	um2.insert(make_pair(2, 2));
	um2.insert(make_pair(3, 3));
	Container<MMap<double>> uc2;
	uc2.print(um2);

	MMap<string> um3;
	um3.insert(make_pair(1, "one"));
	um3.insert(make_pair(2, "two"));
	um3.insert(make_pair(3, "three"));
	Container<MMap<string>> uc3;
	uc3.print(um3);
	
	return 0;
}

?

上面的例子中通过使用using给模板指定别名，就可以基于别名非常方便的给value指定相应的类型，这样使编写的程序变得更加灵活，看起来也更加简洁一些。

最后在强调一点：using语法和typedef一样，并不会创建出新的类型，它们只是给某些类型定义了新的别名。using相较于typedef的优势在于定义函数指针别名时看起来更加直观，并且可以给模板定义别名。