typedef vs using in Templates

The main difference between type aliases (introduced with the using keyword in C++11) and typedefs in terms of template support is that type aliases can be templated, while typedefs cannot. This makes type aliases more flexible and powerful when working with templates. Let's explore this in detail.

Basic Syntax

First, let's review the basic syntax for both:

1// typedef syntax
2typedef std::vector<int> IntVector;
3
4// using syntax (type alias)
5using IntVector = std::vector<int>;

For simple cases like this, both typedef and using are equivalent.

Template Support

The key difference emerges when we want to create a template alias:

1#include <iostream>
2#include <vector>
3
4// This is possible with using
5template <typename T>
6using Vec = std::vector<T>;
7
8// This is not possible with typedef
9template<typename T>
10typedef std::vector<T> Vec;  
11
12int main() {
13  Vec<int> v{1, 2, 3};
14  for (const auto& i : v) {
15    std::cout << i << ' ';
16  }
17}

1error: a typedef template is illegal

With using, we can create a template alias Vec that can be used with any type. This is not possible with typedef.

Complex Template Aliases

Type aliases really shine when dealing with more complex template types:

1#include <iostream>
2#include <map>
3#include <string>
4
5template <typename Key, typename Value>
6using MapWithDefault = std::map<
7  Key, Value, std::less<Key>,
8  std::allocator<std::pair<const Key, Value>>
9>;
10
11int main() {
12  MapWithDefault<std::string, int> myMap;
13  myMap["one"] = 1;
14  myMap["two"] = 2;
15
16  for (const auto& [key, value] : myMap) {
17    std::cout << key << ": " << value << '\n';
18  }
19}

1one: 1
2two: 2

This kind of template alias would be much more cumbersome to express with typedef.

Partial Specialization

Type aliases also allow for partial specialization, which isn't possible with typedef:

1#include <iostream>
2#include <type_traits>
3
4template <typename T>
5using RemoveConst = typename std::remove_const<T>::type;
6
7template <typename T>
8using AddConst = typename std::add_const<T>::type;
9
10int main() {
11  std::cout << std::boolalpha;
12  std::cout
13    << "int is same as RemoveConst<const int>: "
14    << std::is_same_v<int, RemoveConst<const int>>;
15  std::cout
16    << "\nconst int is same as AddConst<int>: "
17    << std::is_same_v<const int, AddConst<int>>;
18}

1int is same as RemoveConst<const int>: true
2const int is same as AddConst<int>: true

Conclusion

While typedef and using are equivalent for simple type aliases, using provides superior template support. This makes using more versatile and generally preferred in modern C++ code, especially when working with templates.

The ability to create template aliases with using can lead to more readable and maintainable code, particularly when dealing with complex template types. For these reasons, using is generally recommended over typedef in new C++ code, especially when template support might be needed.