Does C++11 allow declaring non-static data members as &#39;auto&#39; if they are initialized in the declaration? For example:

    struct S
    {
        auto x = 5;  // in place of &#39;int x = 5;&#39;, which is definitely allowed
    };

GCC 4.7 rejects the above code, while it accepts `int x = 5;`.

Assuming this is not a compiler bug but rather the standard really doesn&#39;t allow it, why not? It would be just as useful as declaring local variables `auto`.

C++11 - declaring non-static data members as &#39;auto&#39;

I&#39;ve been using the new `auto` keyword available in the C++11 standard for complicated templated types which is what I believe it was designed for. But I&#39;m also using it for things like:

    auto foo = std::make_shared&lt;Foo&gt;();

And more skeptically for:

    auto foo = bla(); // where bla() return a shared_ptr&lt;Foo&gt;

I haven&#39;t seen much discussion on this topic. It seems that `auto` could be overused since a type is often a form of documentation and sanity checks. Where do you draw the line in using `auto` and what are the recommended use cases for this new feature?

To clarify: I&#39;m not asking for a philosophical opinion; I&#39;m asking for the intended use of this keyword by the standard committee, possibly with comments on how that intended use is realized in practice.

How much is too much with C++11 auto keyword?

I can see why the `auto` type in C++11 improves correctness and maintainability. I&#39;ve read that it can also improve performance ([Almost Always Auto][1] by Herb Sutter), but I miss a good explanation.

 - How can `auto` improve performance?
 - Can anyone give an example?

  [1]: http://herbsutter.com/2013/08/12/gotw-94-solution-aaa-style-almost-always-auto/


Can the use of C++11&#39;s &#39;auto&#39; improve performance?

If you read code like

`auto&amp;&amp; var = foo();`

where `foo` is any function returning by value of type `T`. Then `var` is an lvalue of type rvalue reference to `T`. But what does this imply for `var`? Does it mean, we are allowed to steal the resources of `var`? Are there any reasonable situations when you should use `auto&amp;&amp;` to tell the reader of your code something like you do when you return a `unique_ptr&lt;&gt;` to tell that you have exclusive ownership? And what about for example `T&amp;&amp;` when `T` is of class type?

I just want to understand, if there are any other use cases of `auto&amp;&amp;` than those in template programming; like the ones discussed in the examples in this article [Universal References][1] by Scott Meyers.


  [1]: http://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers

What does auto&amp;&amp; tell us?

From all the material I used to learn C++, `auto` has always been a weird storage duration specifier that didn&#39;t serve any purpose.  But just recently, I encountered code that used it as a type name in and of itself.  Out of curiosity I tried it, and it assumes the type of whatever I happen to assign to it!

Suddenly STL iterators and, well, anything at all that uses templates is 10 fold easier to write.  It feels like I&#39;m using a &#39;fun&#39; language like Python.

Where has this keyword been my whole life?  Will you dash my dreams by saying it&#39;s exclusive to visual studio or not portable?

C++ auto keyword. Why is it magic?

I came across the following code:

    template &lt;typename T, typename T1&gt; auto compose(T a, T1 b) -&gt; decltype(a + b) {
       return a+b;
    }

There is one thing I cannot understand:
 
Where could I find out what the arrow operator (`-&gt;`) means in the function heading?

I guess purely logically, that the `-&gt;` operator determines a type, that `auto` will be deduced to, but I want to get this straight. I can&#39;t find any information.

Arrow operator (-&gt;) in function heading

In c++14 the `decltype(auto)` idiom is introduced. 

Typically its use is to **allow `auto` declarations to use the `decltype` rules on the given expression**. 

Searching for examples of &quot;good&quot; usage of the idiom I can only think of things like the following (by [Scott Meyers](http://scottmeyers.blogspot.gr/2013/07/when-decltype-meets-auto.html)), namely for **a function&#39;s return type deduction**:

    template&lt;typename ContainerType, typename IndexType&gt;                // C++14
    decltype(auto) grab(ContainerType&amp;&amp; container, IndexType&amp;&amp; index)
    {
      authenticateUser();
      return std::forward&lt;ContainerType&gt;(container)[std::forward&lt;IndexType&gt;(index)];
    }

Are there any other examples where this new language feature is useful?

What are some uses of decltype(auto)?

I had a perception that, type of a lambda is a function pointer. When I performed following test, I found it to be wrong ([demo](http://ideone.com/5ZRRsA)).

    #define LAMBDA [] (int i) -&gt; long { return 0; }
    int main ()
    {
      long (*pFptr)(int) = LAMBDA;  // ok
      auto pAuto = LAMBDA;  // ok
      assert(typeid(pFptr) == typeid(pAuto));  // assertion fails !
    }
Is above code missing any point ? If not then, what is the `typeof` a lambda expression when deduced with `auto` keyword ?

What is the type of lambda when deduced with &quot;auto&quot; in C++11?

It seems that `auto` was a fairly significant feature to be added in C++11 that seems to follow a lot of the newer languages. As with a language like Python, I have not seen any explicit variable declaration (I am not sure if it is possible using Python standards).

Is there a drawback to using `auto` to declare variables instead of explicitly declaring them?


Is there a downside to declaring variables with auto in C++?

I was somehow surprised that the following code compiles and runs (vc2012 &amp; gcc4.7.2)

    class Foo {
        struct Bar { int i; };
    public:
        Bar Baz() { return Bar(); }
    };

    int main() {
        Foo f;
        // Foo::Bar b = f.Baz();  // error
        auto b = f.Baz();         // ok
        std::cout &lt;&lt; b.i;
    }

Is it correct that this code compiles fine? And why is it correct? Why can I use `auto` on a private type, while I can&#39;t use its name (as expected)?

Why can I use auto on a private type?

Is there an `auto` variable type in Java like you have in C++?

An example:

    for ( auto var : object_array)
        std::cout &lt;&lt; var &lt;&lt; std::endl;

    for( auto var : object_array)
        var.do_something_that_only_this_particular_obj_can_do();

I know that there is an enhanced for loop in Java, but is there an auto? If not, is there a hack to doing this? I am referring to the new feature in C++11

Is there auto type inferring in Java?

Consider this fairly useless program:

    #include &lt;iostream&gt;
    int main(int argc, char* argv[]) {
    
      int a = 5;
    
      auto it = [&amp;](auto self) {
          return [&amp;](auto b) {
            std::cout &lt;&lt; (a + b) &lt;&lt; std::endl;
            return self(self);
          };
      };
      it(it)(4)(6)(42)(77)(999);
    }

Basically we are trying to make a lambda that returns itself. 

- MSVC compiles the program, and it runs
- gcc compiles the program, and it segfaults
- clang rejects the program with a message:
&gt;`error: function &#39;operator()&lt;(lambda at lam.cpp:6:13)&gt;&#39; with deduced return type cannot be used before it is defined`

Which compiler is right? Is there a static constraint violation, UB, or neither?

**Update** this slight modification is accepted by clang:

      auto it = [&amp;](auto&amp; self, auto b) {
              std::cout &lt;&lt; (a + b) &lt;&lt; std::endl;
              return [&amp;](auto p) { return self(self,p); };
      };
      it(it,4)(6)(42)(77)(999);

**Update 2**: I understand how to write a functor that returns itself, or how to use the Y combinator, to achieve this. This is more a language-lawyer question.

**Update 3**: the question is *not* whether it is legal for a lambda to return itself in general, but about the legality of this specific way of doing this. 

Related question: [C++ lambda returning itself](https://stackoverflow.com/questions/52173762/c-lambda-returning-itself).


Lambda returning itself: is this legal?

How does generic lambda work (`auto` keyword as an argument type) in C++14 standard? 

Is it based on C++ templates where for each different argument type compiler generates a new function with the same body but replaced types (compile-time polymorphism)  or is it more similar to Java&#39;s generics (type erasure)? 

Code example:

    auto glambda = [](auto a) { return a; };

How does generic lambda work in C++14?

The code:

    int main(void)
    {
        auto a=1;
        return 0;
    }

gets compiled without errors by the MS Visual Studio 2012 compiler, when the file has the .c extension. I have always thought that when you use the .c extension, compilation should be according to the C syntax, and not C++. Moreover, as far as I know auto without a type is allowed **only** in C++ since C++11, where it means that the type is deduced from the initializer.

Does that mean that my compiler isn&#39;t sticking to C, or is the code actually correct in C-language?

Why does auto a=1; compile in C?

When creating local variables, is it correct to use `(const) auto&amp;` or `auto`?

e.g.:

    SomeClass object;
    const auto result = object.SomeMethod();

or `const auto&amp; result = object.SomeMethod();`

Where SomeMethod() returns a non-primitive value - maybe another user-defined type.
My understanding is that `const auto&amp; result` is correct since the result returned by SomeMethod() would call the copy constructor for the returned type. Please correct me if I am wrong. 

What about for primitive types? I assume `const auto sum = 1 + 2;` is correct.

Does this also apply to range based for loops?

    for(const auto&amp; object : objects)






C++ auto&amp; vs auto

&gt; **Possible Duplicate:**  
&gt; [How much is too much with C++0x auto keyword](https://stackoverflow.com/questions/6434971/how-much-is-too-much-with-c0x-auto-keyword)  

&lt;!-- End of automatically inserted text --&gt;

Have we (as a community) had enough experience to determine when and/or whether auto is being abused?

What I am really looking for is a best practices guide on

* when to use auto
* when it should be avoided

Simple rules of thumb that can quickly be followed in 80% of cases.

As a context this question is sparked by my response [here](https://codereview.stackexchange.com/questions/3770/review-my-code-to-write-bittorrent-peer-protocol-messages/3781#3781)


The new keyword &quot;auto&quot;; When should it be used to declare a variable type?

C++11 supports a new function syntax:

    auto func_name(int x, int y) -&gt; int;

Currently this function would be declared as:

    int func_name(int x, int y);

The new style does not seem to be widely adopted yet (say in the gcc stl)

However, should this new style be preferred everywhere in new C++11-programs, or will it only be used when needed?

Personally, I prefer the old style when possible, but a code-base with mixed styles looks pretty ugly.

Should the trailing return type syntax style become the default for new C++11 programs?

Is there a semantic difference between `auto const` and `const auto`, or do they mean the same thing?


Is &#39;auto const&#39; and &#39;const auto&#39; the same?

Please take a look at the following simple code:

    class Foo
    {
    public:
      Foo(){}
      ~Foo(){}
    
      Foo(const Foo&amp;){}
      Foo&amp; operator=(const Foo&amp;) { return *this; }
    };
    
    static Foo g_temp;
    const Foo&amp; GetFoo() { return g_temp; }

I tried to use `auto` like this:

    auto my_foo = GetFoo();

I expected that `my_foo` will be a constant reference to `Foo`, which is the return type of the function. However, the type of `auto` is `Foo`, not the reference. Furthermore, `my_foo` is created by copying `g_temp`. This behavior isn&#39;t that obvious to me.

In order to get the reference to `Foo`, I needed to write like this:

    const auto&amp; my_foo2 = GetFoo();
          auto&amp; my_foo3 = GetFoo();



**Question**: Why does `auto` deduce the return type of `GetFoo` as an object, not a reference?

C++11 auto: what if it gets a constant reference?

Given my variable being a pointer, if I assign it to a variable of &quot;auto&quot; type, do I specify the &quot;*&quot; ?

    std::vector&lt;MyClass&gt; *getVector(); //returns populated vector
    //...

    std::vector&lt;MyClass&gt; *myvector = getVector();  //assume has n items in it
    auto newvar1 = myvector;

    // vs:
    auto *newvar2 = myvector;

    //goal is to behave like this assignment:
    std::vector&lt;MyClass&gt; *newvar3 = getVector();

I&#39;m a bit confused on how this `auto` works in c++11 (this is a new feature to c++11, right?)

**Update:** I revised the above to better clarify how my vector is really populated in a function, and I&#39;m just trying to assign the returned pointer to a variable.  Sorry for the confusion

Does &#39;auto&#39; type assignments of a pointer in c++11 require &#39;*&#39;?

How can I find out what type the compiler deduced when using the ``auto`` keyword?

Example 1: Simpler

    auto tickTime = 0.001;

Was this deduced as a ``float`` or a ``double?``

Example 2: More complex (and my present headache):

    typedef std::ratio&lt;1, 1&gt; sec;
    std::chrono::duration&lt;double, sec &gt; timePerTick2{0.001};
     auto nextTickTime = std::chrono::high_resolution_clock::now() + timePerTick2;

What type is ``nextTickTime``?

The problem I&#39;m having is when I try to send ``nextTickTime`` to ``std::cout``. I get the following error:

    ./main.cpp: In function ‘int main(int, char**)’:
    ./main.cpp:143:16: error: cannot bind ‘std::basic_ostream&lt;char&gt;’ lvalue to ‘std::basic_ostream&lt;char&gt;&amp;&amp;’
      std::cout &lt;&lt; std::setprecision(12) &lt;&lt; nextTickTime &lt;&lt; std::endl; // time in seconds
                ^
    In file included from /usr/include/c++/4.8.2/iostream:39:0,
                 from ./main.cpp:10:
    /usr/include/c++/4.8.2/ostream:602:5: error:   initializing argument 1 of ‘std::basic_ostream&lt;_CharT, _Traits&gt;&amp; std::operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp;&amp;, const _Tp&amp;) [with _CharT = char; _Traits = std::char_traits&lt;char&gt;; _Tp = std::chrono::time_point&lt;std::chrono::_V2::system_clock, std::chrono::duration&lt;double, std::ratio&lt;1l, 1000000000l&gt; &gt; &gt;]’
     operator&lt;&lt;(basic_ostream&lt;_CharT, _Traits&gt;&amp;&amp; __os, const _Tp&amp; __x)


Using &#39;auto&#39; type deduction - how to find out what type the compiler deduced?

I am moving towards C++11 from C++98 and have become familiar with the `auto` keyword. I was wondering why we need to explicitly declare `auto` if the compiler is able to automatically deduce the type. I know C++ is a strongly typed language and this is a rule but was it not possible to achieve the same outcome without explicitly declaring a variable `auto`?

Why do I need to explicitly write the &#39;auto&#39; keyword?

    #include &lt;iostream&gt;
    
    int main(){
    	
    	auto lambda = [] {
    		return 7;
    	};
    	
    	std::cout &lt;&lt; lambda() &lt;&lt; &#39;\n&#39;;
    
    }
This program compiles and prints 7.  
The return type of the lambda is deduced to the integer type based on the return value of 7.


----------


Why isn&#39;t this possible with ordinary functions?

    #include &lt;iostream&gt;
    
    auto function(){
    	return 42;
    }
    
    int main(){
    	
    	std::cout &lt;&lt; function() &lt;&lt; &#39;\n&#39;;
    }
**error: ‘function’ function uses ‘auto’ type specifier without trailing return type**


A lambda&#39;s return type can be deduced by the return value, so why can&#39;t a function&#39;s?


In C++20, we are now able to constrain the `auto` keyword to only be of a specific type. So if I had some code that looked like the following without any constraints:
```
auto something(){
  return 1;
}

int main(){
  const auto x = something();
  return x;
}
```
The variable `x` here is deduced to be an `int`. However, with the introduction of C++20, we can now constrain the `auto` to be a certain type like this:
```
std::integral auto something(){
  return 0;
}

int main(){
  const auto x = something();
  return x;
}
```
Doesn&#39;t this defeat the purpose of `auto` here? If I really need a `std::integral` datatype, couldn&#39;t I just omit the `auto` completely? Am I misunderstanding the use of `auto` completely?



Doesn&#39;t constraining the &quot;auto&quot; in C++ defeat the purpose of it?

First question: is it possible to &quot;force&quot; a `const_iterator` using auto?
For example:

&lt;!-- language: lang-cpp --&gt;

    map&lt;int&gt; usa;
    //...init usa
    auto city_it = usa.find(&quot;New York&quot;);

I just want to query, instead of changing anything pointed by `city_it`, so I&#39;d like to have `city_it` to be `map&lt;int&gt;::const_iterator`. But by using auto, `city_it` is the same to the return type of `map::find()`, which is `map&lt;int&gt;::iterator`. Any suggestion?

How do I get a const_iterator using auto?

In C++11, I can iterate over some container like so:


    for(auto i : vec){
       std::cout &lt;&lt; i &lt;&lt; std::endl;
    }

But I know that this needlessly - *needlessly*, since I only need to *print* the values of `vec` - makes a copy of (**EDIT**:  each element of) `vec`, so instead I could do:

    for(auto &amp;i : vec){
       std::cout &lt;&lt; i &lt;&lt; std::endl;
    }

But I want to make sure that the values of `vec` are never modified and abide by const-correctness, so I can do:

    for(const auto &amp;i : vec){
       std::cout &lt;&lt; i &lt;&lt; std::endl;
    }

So my question is:  If I only need to *look* at the values of some container, wouldn&#39;t the very last loop (`const auto &amp;i`) always be preferred due to the increased effieciency of not having an extra copy of (**EDIT**:  each element of) `vec`?


I have a program that I&#39;m developing in which I&#39;m considering making this change throughout, since efficiency is critical in it (the reason I&#39;m using C++ in the fist place).

C++11 Range-based for-loop efficiency &quot;const auto &amp;i&quot; versus &quot;auto i&quot;

What are the advantages of `auto` in template parameters that will (possibly) be introduced with C++17?

Is it just a natural extension of `auto` when I want to instantiate template code?

    auto v1 = constant&lt;5&gt;;      // v1 == 5, decltype(v1) is int
    auto v2 = constant&lt;true&gt;;   // v2 == true, decltype(v2) is bool
    auto v3 = constant&lt;&#39;a&#39;&gt;;    // v3 == &#39;a&#39;, decltype(v3) is char

What else do I gain from this language feature?




Advantages of auto in template parameters in C++17

I love `auto` in C++11. It&#39;s wonderful. But it has one inconsistency that really gets on my nerves, because I trip over it all the time:

    int i = 3;       // i is an int with value 3
    int i = int{3};  // i is an int with value 3
    int i(3);        // i is an int with value 3 (possibly narrowing, not in this case)
    int i{3};        // i is an int with value 3

    auto i = 3;      // i is an int with value 3
    auto i = int{3}; // i is an int with value 3
    auto i(3);       // i is an int with value 3
    auto i{3};       // wtf, i is a std::initializer_list&lt;int&gt;?!

This strange behaviour is confusing for newcomers, and annoying for experienced users -- C++ has enough little inconsistencies and corner cases that one has to keep in mind as it is. Can anybody explain why standards committee decided to introduce a new one in this case?

I could understand it if declaring a variable of type `std::initializer_list` was something that was useful or done frequently, but in my experience it&#39;s almost never deliberate -- and in the rare cases where you did want to do it, any of

    std::initializer_list&lt;int&gt; l{3};
    auto l = std::initializer_list&lt;int&gt;{3};
    auto l = {3}; // No need to specify the type

would work just fine. So what&#39;s the reason behind the special case for `auto x{i}`?

Why does auto x{3} deduce an initializer_list?

What&#39;s the difference between the types of `bar1` and `bar2`?

    int foo = 10;
    auto bar1 = &amp;foo;
    auto *bar2 = &amp;foo;

If both `bar1` and `bar2` are `int*`, does it makes sense to write the pointer declarator (`*`) in the `bar2` declaration?

C++11 auto declaration with and without pointer declarator

Is there a way to pass auto as an argument to another function?

    int function(auto data)
    {
        //DOES something
    }

Is there a way to pass auto as an argument in C++?

Consider the following program:

    extern int x;
    auto x = 42;
    int main() { }

Clang 3.5 accepts it ([live demo](http://coliru.stacked-crooked.com/a/8346873c11d41df9)), GCC 4.9 and VS2013 do not ([live demo for the former](http://coliru.stacked-crooked.com/a/4d0cfeba70541e49)). Who is right, and where is the correct behavior specified in the C++ Standard?

All Auto Solutions on Gang of Coders

Total of 31 Auto Solutions

C++11 - declaring non-static data members as 'auto'

How much is too much with C++11 auto keyword?

Can the use of C++11's 'auto' improve performance?

What does auto&& tell us?

C++ auto keyword. Why is it magic?

Arrow operator (->) in function heading

What are some uses of decltype(auto)?

What is the type of lambda when deduced with "auto" in C++11?

Is there a downside to declaring variables with auto in C++?

Why can I use auto on a private type?

Is there auto type inferring in Java?

Lambda returning itself: is this legal?

How does generic lambda work in C++14?

Why does auto a=1; compile in C?

C++ auto& vs auto

The new keyword "auto"; When should it be used to declare a variable type?

Should the trailing return type syntax style become the default for new C++11 programs?

Is 'auto const' and 'const auto' the same?

C++11 auto: what if it gets a constant reference?

Does 'auto' type assignments of a pointer in c++11 require '*'?

Using 'auto' type deduction - how to find out what type the compiler deduced?

Why do I need to explicitly write the 'auto' keyword?

A lambda's return type can be deduced by the return value, so why can't a function's?

Doesn't constraining the "auto" in C++ defeat the purpose of it?

How do I get a const_iterator using auto?

C++11 Range-based for-loop efficiency "const auto &i" versus "auto i"

Advantages of auto in template parameters in C++17

Why does auto x{3} deduce an initializer_list?

C++11 auto declaration with and without pointer declarator

Is there a way to pass auto as an argument in C++?

Does a declaration using "auto" match an extern declaration that uses a concrete type specifier?