typename、typedef、using对比

在c++的标准库中，因为类继承关系比较复杂和模板使用比较多的原因，源代码中充斥着typename、typedef和using这三个关键字

一、typename关键字

1.1、typename的第一个作用是用作模板里面，来声明某种类型

template<typename _Tp, typename _Alloc>
    struct _Vector_base;

最开始的时候声明模板形参，也会使用class，但我们都知道class总要是用来指定一个类名，据说是为了避免混淆，所以后来增加了typename这个关键字，它告诉编译器，跟在它后面的字符串是一个不确定的类型，而不是变量或者其他什么东西。

1.2、typename在stl中还有另外一种作用

例1

//test.cpp
#include 
using namespace std;
 
template<typename _Tp, typename _Alloc>
class AA
{
typedef  typename __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type;
};

这里顺便说一下rebind前面为啥要放一个template，它是为了告诉编译器后面的<>是用于指定模板参数，而进行比较。

这个时候我们使用g++ -c test.cpp -o test.o是可以编译通过的，但如果我们去掉第三个typename看，会发生什么呢？

再次编译，报错如下：

test.cpp:8:10: 错误：‘typename __gnu_cxx::__alloc_traits<_Alloc>::rebind<_Tp>::other’之前需要‘typename’，因为‘typename __gnu_cxx::__alloc_traits<_Alloc>::rebind<_Tp>’是一个有依赖的作用域
 typedef  __gnu_cxx::__alloc_traits<_Alloc>::template rebind<_Tp>::other _Tp_alloc_type;

编译器直接指明了需要一个typename，实际上typename在这里也是指定它后面的字符串为类型，这是因为对于形如AA::BB这样的形式，它有可能是一个类型，也有可能是类的静态成员，这个时候加上typename就是为了告诉编译器，它后面的一大串字符串都是一个类型。

template<typename T>
void print2nd(const T& container)
{
　   typename T::const_iterator * x; //①
　   ...
}

如果不加typename此时的编译器会纠结：const_iterator是一个什么东西？const_iterator是模板参数C内的一个static变量？x是一个全局变量？再或者：const_iterator是模板参数C内部的一个typedef。所以此时我们应该告诉编译器const_iterator是模板参数C里面的一个类型。即在C的前面加上typename就可以了

事实上类型T::const_iterator依赖于模板参数T， 模板中依赖于模板参数的名称称为从属名称（dependent name）， 当一个从属名称嵌套在一个类里面时，称为嵌套从属名称（nested dependent name）。 其实T::const_iterator还是一个嵌套从属类型名称（nested dependent type name）。

嵌套从属名称是需要用typename声明的，其他的名称是不可以用typename声明的。

例2

template<typename T>
class myFoo
{
public:
    using size_type = std::size_t;
 
public:
    size_type size() const;
private:
    size_type mSize = 5;
};

template<typename T>
myFoo::size_type myFoo::size() const
{
    return mSize;
}

这种写法仍然不对，也会被编译器无情的拒绝。

因为，对于模板类，myFoo::size_type 这样的写法，会被认为是引用一个名为size_type的成员变量，而这里的size_type只是size_t的别名而已，是个类型名，而不是成员变量。

答案最终揭晓，正确的写法是，保证对size_type的引用是类型名的引用，其实解决方法并不止一种：

• 其一：使用typename关键字，具体代码如下：

template<typename T>
typename myFoo::size_type myFoo::size() const
{
    return mSize;
}

• 其二：使用auto和decltype关键字，具体代码如下(包含模板类的声明部分)：

template<typename T>
class myFoo
{
public:
    using size_type = std::size_t;
 
public:
    auto size() const -> decltype(myFoo::mSize);
private:
    size_type mSize = 5;
};
 
/** size成员函数实现 */
template<typename T>
auto myFoo::size() const -> decltype(myFoo::mSize)
{
    return mSize;
}

二、typedef关键字

typedef实际上就是给类型取了一个别名

三、using关键字

case1、 命名空间的使用

case2、在子类中引用基类的成员（私有保护或者函数隐藏的情况）

class T5Base {
public:
    T5Base() :value(55) {}
    virtual ~T5Base() {}
    void test1() { cout << "T5Base test1..." << endl; }
protected:
    int value;
};
 
class T5Derived : private T5Base {
public:
    //using T5Base::test1;
    //using T5Base::value;
    void test2() { cout << "value is " << value << endl; }
};

基类中成员变量 value 是protected，在 private 继承之后，对于外界这个值为 private，也就是说T5Derived 的对象无法使用这个 value。

如果想要通过对象使用，需要在public下通过 using T5Base::value 来引用，这样 T5Derived 的对象就可以直接使用。

同样的，对于基类中的成员函数 test1()，在private继承后变为 private，T5Derived 的对象同样无法访问，通过 using T5Base::test1 就可以使用了。

注意，using只是引用，不参与形参的指定。

函数隐藏case：

case3、 别名指定

using在c++11以后又有了一种新的作用，那就是与typedef一样，给类型指定别名，形式是这样的：

using 别名=类型;

我们把上面typedef那里的代码改一下，如下

对于函数指针，还可以这样：

using func = int (*)(int a, int b);

四、using 跟typedef有什么区别呢？哪个更好用些呢？

1、可读性

typedef std::unique_ptr> UPtrMapSS;
using UPtrMapSS = std::unique_ptr>;
 
 
typedef std::string (Foo::* fooMemFnPtr) (const std::string&);
using fooMemFnPtr = std::string (Foo::*) (const std::string&);

2、alias templates, 模板别名。

template <typename T>
using Vec = MyVector>;
 
// usage
Vec<int> vec;

这一切都会非常的自然。
那么，若你使用typedef来做这一切：

template <typename T>
typedef MyVector> Vec;
 
// usage
Vec<int> vec;

当你使用编译器编译的时候，将会得到类似：error: a typedef cannot be a template 的错误信息。

虽然两者都用于创建类型别名，但“typedef”的主要限制是它不适用于模板。当涉及到非模板工作时，“using”和“typedef”在机械上都是相同的。因此，在这种情况下，这是程序员的个人选择。

五、调用模板成员函数需不需要加template关键字