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

 

In C++11 and later versions, both typedef and using can be used to define type aliases, making your code more readable and expressive. However, they have slightly different syntax and behavior. The primary difference lies in their flexibility and ability to define more complex type aliases.

Here's a comparison between typedef and using using examples:

1. typedef:
   • typedef is an older way of defining type aliases in C++.
   • It can be a bit cumbersome when dealing with complex types like function pointers or template instantiations.

Example using typedef:

cpp

typedef int IntAlias;
typedef void (*FunctionPointer)(int);

int main() {
    IntAlias x = 42;
    FunctionPointer func = [](int num) { std::cout << "Number: " << num << std::endl; };
    func(x);

    return 0;
}

2. using:
   • using provides a more modern and flexible syntax for defining type aliases.
   • It can handle complex type aliases and is often more intuitive.

Example using using:

cpp

using IntAlias = int;
using FunctionPointer = void (*)(int);

int main() {
    IntAlias x = 42;
    FunctionPointer func = [](int num) { std::cout << "Number: " << num << std::endl; };
    func(x);

    return 0;
}

In both examples, we define type aliases for int and a function pointer type. The syntax using using is often considered more readable, especially when working with more complex types or when creating template aliases.

Note that using can also be used to create template aliases, which is something typedef cannot do:

cpp

template <typename T>
using Ptr = T*;

int main() {
    Ptr<int> p = new int(5);
    std::cout << *p << std::endl; // Output: 5
    delete p;

    return 0;
}

In this example, we create a template alias Ptr using using, which is not possible using typedef.

In summary, both typedef and using serve the purpose of creating type aliases, but using is more flexible and recommended for modern C++ code. It's particularly useful when dealing with complex types or creating template aliases.