what does type alias do in classes?

user_12416947 0
Viewed 102

I got curious and looked at the implementation details of the std::vector. I don't understand a lot of the code but I was confused about the "using" declarations'. I see that a lot of classes also include those using statements or typedef within their classes. What is the point of using a using declaration within your class? Does it introduce a new member variable or something? I am confused about how it works.

using iterator               = _Vector_iterator<_Scary_val>;
using const_iterator         = _Vector_const_iterator<_Scary_val>;
using reverse_iterator       = _STD reverse_iterator<iterator>;
using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
using c++
2 Answers

using was introduced in C++11 as a more advanced and flexible replacement for typedef, particularly in template metaprogramming.

Whether typedef or using is used, standard containers define a common set of inner type aliases, so that code can be written in a more generic manner, particularly in template metaprogramming. For instance, you can write a function that accepts any standard container as input, and then use its inner aliases without having to know the type of the container itself. This allows you to easily switch between containers without having to re-write the code that is using the containers. For example 1:

template<typename Container>
void doSomething(const Container &c) {
    for(typename Container::const_iterator iter = c.cbegin(); iter != c.cend(); ++iter) {
        // use *iter as needed ...
    }
}

1: obviously, there are better ways to write this nowadays, like for(const auto &elem : c) { ... }.

So, maybe one day you start out using std::vector, eg:

std::vector<int> v;
...
doSomething(v);

And then later on you decide to use std::list instead, eg:

std::list<int> l;
...
doSomething(l);

You can change the type of container used, without having to change the function itself.

user_658630

These declarations declare type members of the class. Just as a class may have data members, it can also have type members (they take up no space as they are compile time constructs). Some of the type members are prescribed by the C++ standard. Some are just for convenience so that you can use abbreviated type names instead of a type name that may not even fit in one line. Some others are provided to interoperate with the C++ library, ie. the library may place requirements on user types passed to it, requiring that certain member types are present within those types. Some times, the type aliases are used to expose an internal implementation detail in a form that is thus made public. Ie. a class may have some private template member types, whose particular instantiation can be exposed using such an alias, without exposing the generic (templated) type.

Finally, using type aliases helps with compiler performance in template-heavy code: if you have a choice between making a new type (that eg derives from another type, or contains a type) or using a convenient alias, then the alias will have significantly lower memory and performance impact during compilation. This only applies to template metaprogramming and is less of a concern in less template-heavy code as facilitated by modern C++.

user_13296520
Related