auto and decltype


Cyganek section 3.7

We’ve already seen how using auto can make it easier to declare a variable when the compiler can infer the proper type.

For instance, consider a vector:

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

auto it = int_vec.cbegin();

If we wanted to use the actual type for it, we’d need to look in the vector header file for the cbegin() function definition to see what it returned (or use a smart IDE that could do that for us). And then this is what we would have to write:

std::vector<int>::const_iterator it = int_vec.cbegin();

That’s a lot more verbose. So using auto is a very convenient way of declaring this iterator.

We could also use auto in situations like this:

auto x{0.0};

Here the compiler will make x a double, since we have a floating point number in the initialization list, {}. But this case is less useful, and perhaps less clear to someone reading the code. Usually when you are defining a variable, you have in mind what type it should be, so erring on the side of being explicit is a good idea.

Note that if we intended for x to be a const (and indeed, 0.0 is a const, so why didn’t it deduce that?), then we need to be explicit:

const auto x{0.0};

Again, I would advise against using auto in this situation.


decltype is in some ways the opposite of auto. Imagine that we want to declare a new variable to be of the same type as an existing one – this is where decltype comes into play.

Here’s an example:

Listing 11 vector-decltype.cpp
#include <iostream>
#include <vector>

int main() {

    char c{'a'};

    std::vector<decltype(c)> myvec(10, c);

    for (auto e : myvec) {
        std::cout << e;
    std::cout << std::endl;