What is the difference between 'typedef' and 'using' in C++11?

Question

I know that in C++11 we can now use `using` to write type alias, like `typedef`s: typedef int MyInt; Is, from what I understand, equivalent to: using MyInt = int; And that new syntax emerged from the effort to have a way to express "`template typedef`": template< class T > using MyType = AnotherType< T, MyAllocatorType >; But, with the first two non-template examples, are there any other subtle differences in the standard? For example, `typedef`s do aliasing in a "weak" way. That is it does not create a new type but only a new name (conversions are implicit between those names). Is it the same with `using` or does it generate a new type? Are there any differences?

Answer 1

Both using and typedef are equivalent, in that they both declare a type alias.

typedef example:

#include <vector>

typedef std::vector<int>::iterator intIterator;

intIterator it;

using example:

#include <vector>

using intIterator = std::vector::iterator;

intIterator it;

Both are identical aliases... so why use the using keyword, as opposed to typedef?

The benefit of using becomes very useful for alias templates. In the example above, the aliases are set to the type that we defined; in this case, the int data type. We can use the using keyword to declare a template alias, which allows the underlying type to change ( it's why we love templates so much :)

Let's look at a full example:

#include <iostream>

#include <vector>

template <typename T>

using Iterator = typename std::vector<T>::iterator;

int main(int argc, const char * argv[]) {

     

  std::vector<int> vec {0,1,2,3,4};

std::vector<double> vec2 {0.0, 1.5, 2.25, 3.1415, 5};

   

  for (Iterator<int> it=vec.begin(); it != vec.end(); ++it) {

    std::cout << *it << '\n';

  }

for (Iterator<double> it=vec2.begin(); it != vec2.end(); ++it) {

    std::cout << *it << '\n';

  }

  return 0;

}

Output:

0

1

2

3

4

0

1.5

2.25

3.1415

5

Notice how the using keyword allowed us to define a type alias (Iterator) that allowed the underlying type to change; in this case, to be defined as an iterator of integers and then as an iterator of doubles.

I hope this helps!