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

Question

Given my variable being a pointer, if I assign it to a variable of "auto" type, do I specify the "*" ?

std::vector<MyClass> *getVector(); //returns populated vector //...  std::vector<MyClass> *myvector = getVector();  //assume has n items in it auto newvar1 = myvector;  // vs: auto *newvar2 = myvector;  //goal is to behave like this assignment: std::vector<MyClass> *newvar3 = getVector(); 

I'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'm just trying to assign the returned pointer to a variable. Sorry for the confusion

Answer 1

auto newvar1 = myvector;  // vs: auto *newvar2 = myvector; 

Both of these are the same and will declare a pointer to std::vector<MyClass> (pointing to random location, since myvector is uninitialized in your example and likely contains garbage). So basically you can use any one of them. I would prefer auto var = getVector(), but you may go for auto* var = getVector() if you think it stresses the intent (that var is a pointer) better.

_{I must say I never dreamt of similar uncertainity using auto. I thought people would just use auto and not think about it, which is correct 99 % of the time - the need to decorate auto with something only comes with references and cv-qualifiers.}

However, there is slight difference between the two when modifies slightly:

auto newvar1 = myvector, newvar2 = something; 

In this case, newvar2 will be a pointer (and something must be too).

auto *newvar1 = myvector, newvar2 = something; 

Here, newvar2 is the pointee type, eg. std::vector<MyClass>, and the initializer must be adequate.

In general, if the initializer is not a braced initializer list, the compiler processes auto like this:

1. It produces an artificial function template declaration with one argument of the exact form of the declarator, with auto replaced by the template parameter. So for auto* x = ..., it uses

   template <class T> void foo(T*); 

2. It tries to resolve the call foo(initializer), and looks what gets deduced for T. This gets substituted back in place of auto.

3. If there are more declarators in a single declarations, this is done for all of them. The deduced T must be the same for all of them...