C++11 新特性:decltype

参考文章:https://blogs.oracle.com/pcarlini/entry/c_11_tidbits_decltype_part

decltype是 GCC 实现的第一个 C++ 11 新特性。它实际上起源于一个相当古老的 GNU 扩展关键字——__typeof__。这个非标准关键字也能够在 C 语言中使用,GNU Compiler Collection 的专业用户可能对它更熟悉一些。2008 年,GCC 4.3.x 就实现了这个特性,同时去除了__typeof__的一些缺点。现在,decltype__decltype两个关键字在 GCC 中都适用;前者只能用在 C++ 11 模式下,后者可以同时应用于 C++ 11 和 C++ 98 模式。__typeof__则已经停止使用。

下面来看看decltype的基本使用。简单来说,decltype关键字用于查询表达式的类型。不过,这只是其基本用法。当这个简单的表述同 C++ 11 的其它特性结合起来之后,一些意想不到的有趣用法就此产生。

decltype的语法是

decltype ( expression )

这里的括号是必不可少的。根据前面的说法,decltype的作用是“查询表达式的类型”,因此,上面语句的效果是,返回 expression 表达式的类型。注意,decltype 仅仅“查询”表达式的类型,并不会对表达式进行“求值”。

先看一个最基础的例子:

const int&& foo();
int i;
struct A { double x; };
const A* a = new A();

decltype(foo())  x1;  // const int&&      (1)
decltype(i)      x2;  // int              (2)
decltype(a->x)   x3;  // double           (3)
decltype((a->x)) x4;  // double&          (4)

传统的__typeof__有一个颇为诟病的地方,在于不能很好地处理引用类型。而decltype则没有这个问题。而decltype实际上更好地融入了 C++ 11 类型系统,来看一个比较复杂的例子:

int    i;
float  f;
double d;

typedef decltype(i + f) type1;  // float
typedef decltype(f + d) type2;  // double
typedef decltype(f < d) type3;  // bool

上面的例子清楚看出,decltype 能够很好地处理类型转换这里问题。

或许你会对上面代码中的 (4) 心生疑问。为什么decltype((a->x))会是double&?这是由 decltype 的定义决定的。decltype 判别的规律还是比较复杂的:

对于decltype( e )而言,其判别结果受以下条件的影响:

  1. 如果e是一个标识符或者类成员的访问表达式,则decltype(e)就是e所代表的实体的类型。如果没有这种类型或者e是一个重载函数集,那么程序是错误的(上例中的 (2) 和 (3));
  2. 如果e是一个函数调用或者一个重载操作符调用(忽略e外面的括号),那么decltype(e)就是该函数的返回类型(上例中的 (1));
  3. 如果e不属于以上所述的情况,则假设e的类型是 T:当e是一个左值时,decltype(e)就是T&;否则(e是一个右值),decltype(e)是T(上例中的 (4) 即属于这种情况。在这个例子中,e实际是(a->x),由于有这个括号,因此它不属于前面两种情况,所以应当以本条作为判别依据。而(a->x)是一个左值,因此会返回double &)。

说了这么多,decltype到底有什么用?事实上,decltype在复杂的模板编程中非常有用。不过,这需要结合我们前面提到的auto关键字。举个经典的例子,请看下面的代码:

template<typename T, typename U>
??? foo(T t, U u)
{
    return t + u;
}

问号这里该填写什么呢?

问题的关键在于,我们正在处理模板,因此我们根本不知道 T 和 U 的实际类型。即使这两个模板值实际都是 C++ 内置类型,我们也无法确切地知道它们的和的类型。在过去的 GNU C++ 运行时库中,我们可以使用前面说过的__typeof__扩展,编写相当难看的代码:

template<typename T, typename U>
decltype((*(T*)0) + (*(U*)0)) foo(T t, U u)
{
    return t + u;
}

而在 C++11 中,我们可以使用auto关键字:

template<typename T, typename U>
auto foo(T t, U u) -> decltype(t + u) { return t + u; }

看起来好多了吧!现在这已经是语言级别的支持了。

最后,我们来看一个更加实际的例子。在 GCC 的 C++11 运行时库中有这么一段代码:

template<typename _IteratorL, typename _IteratorR>
inline auto operator-(const reverse_iterator<_IteratorL>& __x,
                      const reverse_iterator<_IteratorR>& __y)
    -> decltype(__y.base() - __x.base())
{
    return __y.base() - __x.base();
}

现在,这段代码应该更加清晰了。这实际上解决了 C++ 98 实现的一个真正的 bug。在 GCC 的 C++ 98 版本中,这段代码是这样的:

template<typename _IteratorL, typename _IteratorR>
inline typename reverse_iterator<_IteratorL>::difference_type operator-(
          const reverse_iterator<_IteratorL>& __x,
          const reverse_iterator<_IteratorR>& __y)
{
    return __y.base() - __x.base();
}

这段代码只有在这两方的difference_type相同时才适用。

4 Comments

  1. Toxsch 2013年12月17日
    • 豆子 2013年12月17日
  2. pp 2016年6月23日
    • 豆子 2016年6月23日

Leave a Reply