我知道在c++ 11中,我们现在可以使用using来编写类型别名,比如typedefs:

typedef int MyInt;

在我看来,相当于:

using MyInt = int;

新语法的出现是为了有一种表达“template typedef”的方法:

template< class T > using MyType = AnotherType< T, MyAllocatorType >;

但是,对于前两个非模板示例,标准中还有其他细微的差异吗?例如,typedef以一种“弱”的方式进行混叠。也就是说,它不创建新类型,而只创建新名称(这些名称之间的转换是隐式的)。

它和使用是一样的还是生成一个新的类型?有什么不同吗?


当前回答

以下所有标准参考资料均参考N4659: 2017年3月后kona工作草案/ c++ 17 DIS。


Typedef声明可以用作初始化语句,而别名声明不能(+)

但是,对于前两个非模板示例,是 标准上还有其他细微的差别吗?

语义上的差异:无。 允许上下文中的差异:一些(++)。

(+) P2360R0(扩展初始化语句以允许别名声明)已经被CWG批准,从c++ 23开始,类型定义声明和别名声明之间的不一致将被消除。 (++)除了别名模板的例子,这在原来的帖子中已经提到过。

相同的语义

由[dcl.]管理。/2[提取,强调矿山]

(dcl。typedef) / 2 类型名 还可以介绍一个 alias-declaration。 using关键字后面的标识符变成a typef -name和标识符后面的可选属性说明符-seq都属于该typef -name。这样一个 typepedef -name具有与typedef说明符引入的相同的语义。[…]

由别名声明引入的typepedef -name与由typedef声明引入的typef -name具有相同的语义。

允许上下文的细微差别

然而,这并不意味着这两种变体在使用上下文方面有相同的限制。实际上,尽管是极端情况,typedef声明是一个初始化语句,因此可以在允许初始化语句的上下文中使用

// C++11 (C++03) (init. statement in for loop iteration statements).
for (typedef int Foo; Foo{} != 0;)
//   ^^^^^^^^^^^^^^^ init-statement
{
}

// C++17 (if and switch initialization statements).
if (typedef int Foo; true)
//  ^^^^^^^^^^^^^^^ init-statement
{
    (void)Foo{};
}

switch (typedef int Foo; 0)
//      ^^^^^^^^^^^^^^^ init-statement
{
    case 0: (void)Foo{};
}

// C++20 (range-based for loop initialization statements).
std::vector<int> v{1, 2, 3};
for (typedef int Foo; Foo f : v)
//   ^^^^^^^^^^^^^^^ init-statement
{
    (void)f;
}

for (typedef struct { int x; int y;} P; auto [x, y] : {P{1, 1}, {1, 2}, {3, 5}})
//   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ init-statement
{
    (void)x;
    (void)y;
}

而别名声明不是初始化语句,因此不能在允许初始化语句的上下文中使用

// C++ 11.
for (using Foo = int; Foo{} != 0;) {}
//   ^^^^^^^^^^^^^^^ error: expected expression

// C++17 (initialization expressions in switch and if statements).
if (using Foo = int; true) { (void)Foo{}; }
//  ^^^^^^^^^^^^^^^ error: expected expression

switch (using Foo = int; 0) { case 0: (void)Foo{}; }
//      ^^^^^^^^^^^^^^^ error: expected expression

// C++20 (range-based for loop initialization statements).
std::vector<int> v{1, 2, 3};
for (using Foo = int; Foo f : v) { (void)f; }
//   ^^^^^^^^^^^^^^^ error: expected expression

其他回答

它们本质上是相同的,但使用别名模板是非常有用的。我能找到的一个很好的例子如下:

namespace std {
 template<typename T> using add_const_t = typename add_const<T>::type;
}

因此,我们可以使用std::add_const_t<T>来代替typename std::add_const<T>::type

到目前为止,c++ 23将typedef和using更紧密地结合在一起:P2360建议使用构成初始化语句,例如@dfrib的回答中列出的那些作为error: expected表达式。

然而,即使使用P2360,类型定义也不能是模板。

(编辑[2022-09-14]:信息不正确。)

总的来说,using严格来说比typedef更强大,而且在我看来可读性也更好。

它们在很大程度上是相同的,除了:

别名声明与模板兼容,而C 样式typedef则不是。

我知道最初的海报有一个很好的答案,但对于任何像我一样在这个话题上跌跌撞撞的人来说,提案中有一个重要的说明,我认为它为这里的讨论增加了一些有价值的东西,特别是评论中关于typedef关键字是否将在未来被标记为已弃用,或因冗余/旧而被删除的问题:

It has been suggested to (re)use the keyword typedef ... to introduce template aliases: template<class T> typedef std::vector<T, MyAllocator<T> > Vec; That notation has the advantage of using a keyword already known to introduce a type alias. However, it also displays several disavantages [sic] among which the confusion of using a keyword known to introduce an alias for a type-name in a context where the alias does not designate a type, but a template; Vec is not an alias for a type, and should not be taken for a typedef-name. The name Vec is a name for the family std::vector<•, MyAllocator<•> > – where the bullet is a placeholder for a type-name.Consequently we do not propose the “typedef” syntax.On the other hand the sentence template<class T> using Vec = std::vector<T, MyAllocator<T> >; can be read/interpreted as: from now on, I’ll be using Vec<T> as a synonym for std::vector<T, MyAllocator<T> >. With that reading, the new syntax for aliasing seems reasonably logical.

对我来说,这意味着在c++中继续支持typedef关键字,因为它仍然可以使代码更具可读性和可理解性。

更新using关键字是专门针对模板的,并且(正如在已接受的答案中指出的那样)当您使用非模板时,using和typedef在机械上是相同的,因此,基于可读性和意图的交流,选择完全取决于程序员。

using语法在模板中使用时具有优势。如果需要类型抽象,还需要保留模板参数以便将来可以指定。你应该这样写。

template <typename T> struct whatever {};

template <typename T> struct rebind
{
  typedef whatever<T> type; // to make it possible to substitue the whatever in future.
};

rebind<int>::type variable;

template <typename U> struct bar { typename rebind<U>::type _var_member; }

但是使用语法简化了这个用例。

template <typename T> using my_type = whatever<T>;

my_type<int> variable;
template <typename U> struct baz { my_type<U> _var_member; }