What is the point of the 'auto' keyword?

Question

So I understand using var in C# makes sense because you have anonymous types that are compiler derived. C++ doesn't seem to have this feature (unless I'm wrong), so what is the point of having an auto keyword?

(It is kinda cool that unlike C#, auto does work for member/global variables, which is cool I guess, but doesn't seem enough to justify its existence).

Answer 1

so, let's learn type inference first which is basically refers to automatic deduction of the data type of an expression in a programming language.

before C++ 11 all the variables in c++ have to explicitly declare but after the release of c++ 11, the compiler itself deduces the type of the variable at runtime.

we can use it for variables and even in the case of function return types. but, it's suggested to avoid using auto in function return type.

Answer 2

In C++, auto keyword provides a way of type deduction mechanism. For example,

   auto i = expressions;

auto keyword tells the compiler to determine the type of variable i from the expression on the right side of the assignment operator.

Therefore if the value of expressions is double, then variable i will be double. Or, if the value of expressions is bool, then variable i will be bool.

Answer 3

It is well worth reading Herb Sutter's article Almost Always Auto for some great examples of why it's worth using auto over explicit types. The main advantages are the reduction in typing, and gives additional safety if the underlying types change. One of my favourite examples though is about how it reduces duplication. If you allocate on the stack then you'd use:

MyClass c(param);

However, if you want to create on the heap you need:

MyClass* c=new MyClass(param);

So you've had to duplicate the MyClass, but the RHS already forces the variable to be a MyClass pointer, so you can just use this instead:

auto c=new MyClass(param);

If you want to declare it as a unique_ptr then previously you would need:

unique_ptr<MyClass> c=make_unique<MyClass>(param);

which can be abbreviated to:

auto c=make_unique<MyClass>(param);

Answer 4

syntactic sugar

I rather say

auto i = mapping.begin();

over

std::map<int, int>::iterator i = mapping.begin();

Answer 5

C++ does have "anonymous" types - types you cannot refer to by name because the name is not available to you. This was the case even before C++11 and lambdas. Consider the following code:

class foo {
    class bar { 
      public:
        void baz() { }
    };
  public:        
    static bar func() { return bar(); }
};

foo::func().baz(); // OK, only the name "bar" is private
??? a = foo::func(); // Umm...
auto b = foo::func(); b.baz(); // Hooray!

Even if not actually declared in a private scope, it is often useful for a library to leave some types unspecified in its API - especially when heavily utilizing expression templates or other template metaprogramming where the type names can be arbitrarily long with all the nested template arguments. Even the standard itself does this - for instance, the result type of std::bind is not defined by the specification.

Answer 6

There are a number of uses for auto in C++

1. Anonymous function objects, aka closures, aka lambda instances. auto is the only way to store them. Types can also be generated derived off those types, and types on their backs, ad infinitum.

2. C++ can have quite complex types, such as the type of a non mutating iterator into an unordered map that uses a custom allocator and hashing function. typedef can mitigate this, but the type of a m.begin() having a particular name is not that informative: foo_iterator it = is as meaningful as auto foo_iterator =, and the auto one does not require boilerplate elsewhere.

3. Return type deduction uses the auto keyword, which is required to do some template functions work without huge amounts of traits boilerplate. Eliminating boilerplate is a common theme: C++s robust type system means that types can carry lots of information, and encoding it at every use can be counterproductive.

4. In some ducktype template code, the work to deduce the type of a variable is roughly the same as the work to code the variables value, and nearly identical in structure, some times literally: decltype(long expression) x = long expression;. auto eliminates that duplication.

5. Finally in C++1y, type deduction lambdas use auto to say that an argument is a deduced one. Sort of a light weight template. Talk to extend this to non lambdas is also in skunkworks.

Answer 7

HEre's a real life example where I could not, not use auto

I was trying to do a switch type statement in C++ where the return type is implementation specific and could not be declared easily. So using an 'auto' is probably the right way to resolve the type look up for the map declaration.

auto foo = boost::bind(&VegaFactory::load_commodity_one_leg,this,conn,_1);
std::map<std::string,decltype(foo)> methods;
methods.insert(std::make_pair("FOO",commodityOneLeg));

auto f = methods.find(bar);
// Call f here

Answer 8

auto has a lot of uses when it comes down to both generic programming and to save the programmer some typing.

For example, consider this. Would you rather type out:

std::unique_ptr<name::long_type::goes_here> g = 
    std::make_unique<name::long_type::goes_here>(1,2,3,4)

or:

auto g = std::make_unique<name::long_type::goes_here>(1,2,3,4)

Yes, they're both long but we know the return type and specifying it again is a bit cumbersome to type. This also goes for iterators:

for(auto i = vec.begin(); ...)

vs:

for(std::vector<type>::iterator i = vev.begin(); ...)

Its use in generic programming is also to figure out the return type of a function or if you're doing some generic algorithms where you don't know the type.

For example, consider a very basic example.

template<typename T, typename U>
auto add(T t, U u) -> decltype(t + u) {
    return t + u;
}

This allows the compiler to figure out the type of the add operation rather than us trying to figure it out ourselves. Note that in C++14 you can omit the trailing return type. Its uses in generic programming don't stop there either. If we wanted to work with any type of container as a wrapper function for algorithms we could use auto to help us with it. For example:

template<class Cont>
void my_sort(Cont&& cont) {
    using std::begin;
    auto first = begin(std::forward<Cont>(cont));
    // work with the iterators here
}

In the future (C++14), auto can be used to make polymorphic lambdas as well such as:

[](auto a) { return a + 4; }

Which can be useful as well.