c++11新特性篇-using的使用

Using的使用

using 在 C++11 之前就有，但在 C++11 中引入了一些扩展和新的用法。

类型别名

• **类型别名：**是一个名字，它是同种类型的同义词
• 两种方法可用于定义类型别名：
  • 关键字：typedef
  • C++11新标准中的：using

Using与typedef

typedef

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

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

被重定义的类型并不是一个新的类型，仅仅只是原有的类型取了一个新的名字。

再看一个复杂点的例子:

typedef double wages; //wages是double的同义词
typedef wages base,*p; //base是double的同义词，p是double*的同义词

wages number=3.14; //double number=3.14;
p=&number; //double* p=&number;

上面两行代码将 wages 定义为 double 的别名，所以后续使用 wages 就相当于使用 double。

将 base 定义为 wages 的别名，而 *p 定义为 wages* 的别名，即指向 wages（也就是 double）类型的指针。

综合起来就是:

typedef double wages;  // wages 是 double 的别名
typedef wages base;    // base 是 wages（也就是 double）的别名
typedef wages* p;       // p 是指向 wages（也就是 double）类型的指针的别名

using

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

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

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

代码示例:

using SI=double; //SI等价于double
using p_SI=double*; //p_SI等价于double*
 
SI number=3.14; //double number=3.14;
p_SI p=&number; //double* p=&number;

通过using和typedef的语法格式可以看到二者的使用没有太大的区别，假设我们定义一个函数指针，using的优势就能凸显出来了，看一下下面的例子：

// 使用typedef定义函数指针
typedef int(*func_ptr)(int, double);

// 使用using定义函数指针
using func_ptr1 = int(*)(int, double);

如果不是特别熟悉函数指针与typedef，第一眼很难看出func_ptr其实是一个别名，其本质是一个函数指针，指向的函数返回类型是int，函数参数有两个分别是int，double类型。

使用using定义函数指针别名的写法看起来就非常直观了，把别名的名字强制分离到了左边，而把别名对应的实际类型放在了右边，比较清晰，可读性比较好。

指针、常量和类型别名关系

• 如果某个类型别名指代的是复合类型或常量，那么要注意以下的特殊情况

typedef char* pstring;

    char s = 'A';
    const pstring cstr = &s;
    const pstring* ps = &cstr;
    // const char** ps = &cstr; // "const pstring*"类型的值不能用于初始化“const char **”类型的实体
    printf("%c", **ps);//打印A

• 在上面的代码中，cstr是指向char的常量指针。而ps是一个二级指针，它的对象是指向char*指针的常量指针

模板的别名

使用typedef重定义类似很方便，但是它有一点限制，比如无法重定义一个模板，比如我们需要一个固定以int类型为key的map，它可以和很多类型的value值进行映射，如果使用typedef这样直接定义就非常麻烦:

typedef map<int, string> m1;
typedef map<int, int> m2;
typedef map<int, double> m3;

在这种情况下我们就不自觉的想到了模板：

template <typename T>
typedef map<int, T> type;	// error, 语法错误

使用typename不支持给模板定义别名，这个简单的需求仅通过typedef很难办到，需要添加一个外敷类：

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

template <typename T>
// 定义外敷类
struct MyMap
{
    typedef map<int, T> type;
};

int main(void)
{
    MyMap<string>::type m;
    m.insert(make_pair(1, "luffy"));
    m.insert(make_pair(2, "ace"));

    MyMap<int>::type m1;
    m1.insert(1, 100);
    m1.insert(2, 200);

    return 0;
}

通过上边的例子可以直观的感觉到，需求简单但是实现起来并不容易。在C++11中，新增了一个特性就是可以通过使用using来为一个模板定义别名，对于上面的需求可以写成这样：

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

完整的示例代码如下:

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

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

int main(void)
{
    // map的value指定为string类型
    mymap<string> m;
    m.insert(make_pair(1, "luffy"));
    m.insert(make_pair(2, "ace"));

    // map的value指定为int类型
    mymap<int> m1;
    m1.insert(1, 100);
    m1.insert(2, 200);

    return 0;
}

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

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