Sự khác biệt giữa 'typedef' và 'using' trong C ++ 11 là gì?

Tôi biết rằng trong C ++ 11 bây giờ chúng ta có thể sử dụng usingđể viết bí danh, như typedefs:

typedef int MyInt;

Là, từ những gì tôi hiểu, tương đương với:

using MyInt = int;

Và cú pháp mới đó xuất hiện từ nỗ lực để có cách diễn đạt " template typedef":

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

Nhưng, với hai ví dụ phi mẫu đầu tiên, có sự khác biệt tinh tế nào khác trong tiêu chuẩn không? Ví dụ: typedefs làm răng cưa theo cách "yếu". Đó là nó không tạo ra một loại mới mà chỉ có một tên mới (chuyển đổi được ẩn giữa các tên đó).

Nó giống với usinghoặc nó tạo ra một loại mới? Có sự khác biệt nào không?

Chúng là tương đương, từ tiêu chuẩn (nhấn mạnh của tôi) (7.1.3.2):

Tên typedef cũng có thể được giới thiệu bằng một khai báo bí danh. Mã định danh theo sau từ khóa đang sử dụng trở thành tên typedef và thuộc tính-specifier-seq tùy chọn theo sau định danh xác định với tên typedef đó. Nó có cùng ngữ nghĩa như thể được giới thiệu bởi công cụ xác định typedef. Cụ thể, nó không định nghĩa một loại mới và nó sẽ không xuất hiện trong id loại.

Chúng phần lớn giống nhau, ngoại trừ:

Khai báo bí danh tương thích với các mẫu, trong khi typedef kiểu C thì không.

Các sử dụng cú pháp có lợi thế khi được sử dụng trong các mẫu. Nếu bạn cần loại trừu tượng, nhưng cũng cần giữ tham số mẫu để có thể được chỉ định trong tương lai. Bạn nên viết một cái gì đó như thế này.

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; }

Nhưng sử dụng cú pháp đơn giản hóa trường hợp sử dụng này.

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

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

Chúng cơ bản giống nhau nhưng usingcung cấp alias templateskhá hữu ích. Một ví dụ điển hình tôi có thể tìm thấy như sau:

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

Vì vậy, chúng ta có thể sử dụng std::add_const_t<T>thay vìtypename std::add_const<T>::type

Tôi biết người đăng ban đầu có một câu trả lời tuyệt vời, nhưng đối với bất kỳ ai vấp phải chủ đề này như tôi có một lưu ý quan trọng từ đề xuất mà tôi nghĩ sẽ bổ sung thêm giá trị cho cuộc thảo luận ở đây, đặc biệt là những lo ngại trong các nhận xét về việc nếu typedeftừ khóa là sẽ bị đánh dấu là không dùng nữa trong tương lai hoặc bị xóa vì dư thừa / cũ:

Nó đã được đề xuất (tái) sử dụng từ khóa typedef ... để giới thiệu bí danh mẫu:

template<class T>
  typedef std::vector<T, MyAllocator<T> > Vec;

Ký hiệu đó có lợi thế là sử dụng một từ khóa đã biết để giới thiệu một bí danh loại. Tuy nhiên, nó cũng hiển thị một số biến dạng [sic] trong đó có sự nhầm lẫn khi sử dụng từ khóa được biết để giới thiệu bí danh cho một tên loại trong ngữ cảnh mà bí danh không chỉ định một loại, mà là một mẫu; Veclà không một bí danh cho một loại, và không nên được thực hiện cho một typedef-name. Tên Vecnày là tên của gia đình std::vector<•, MyAllocator<•> >- trong đó viên đạn là một trình giữ chỗ cho một loại tên. Thông thường, chúng tôi không đề xuất cú pháp typedef ấn. Mặt khác, câu

template<class T>
  using Vec = std::vector<T, MyAllocator<T> >;

có thể được đọc / giải thích như sau: từ bây giờ, tôi sẽ sử dụng Vec<T>làm từ đồng nghĩa chostd::vector<T, MyAllocator<T> > . Với cách đọc đó, cú pháp mới cho bí danh có vẻ hợp lý hợp lý.

Đối với tôi, điều này ngụ ý tiếp tục hỗ trợ cho typedeftừ khóa trong C ++ vì nó vẫn có thể làm cho mã dễ đọc và dễ hiểu hơn .

Cập nhật using từ khóa đã được cụ thể đối với các mẫu, và (như đã được chỉ ra trong câu trả lời được chấp nhận) khi bạn đang làm việc với những người không mẫu usingvà typedeflà một cách máy móc giống hệt nhau, vì vậy sự lựa chọn là hoàn toàn lên đến các lập trình viên trên cơ sở khả năng đọc và truyền thông về ý định .

Cả hai từ khóa đều tương đương, nhưng có một vài cảnh báo. Một là khai báo một con trỏ hàm với using T = int (*)(int, int);rõ ràng hơn với typedef int (*T)(int, int);. Thứ hai là mẫu bí danh mẫu là không thể với typedef. Thứ ba là việc phơi bày API C sẽ yêu cầu typedeftrong các tiêu đề công khai.

Khai báo Typedef có thể, trong khi khai báo bí danh không thể, được sử dụng làm câu lệnh khởi tạo

Nhưng, với hai ví dụ phi mẫu đầu tiên, có sự khác biệt tinh tế nào khác trong tiêu chuẩn không?

Mặc dù là một trường hợp góc, một khai báo typedef là một câu lệnh init và do đó có thể được sử dụng trong các ngữ cảnh cho phép các câu lệnh khởi tạo

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

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

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

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

trong khi một bí danh-khai là không một init-tuyên bố , và có thể do đó không được sử dụng trong bối cảnh cho phép báo cáo khởi

// 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