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

by 
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…

More Related Contents:

  1. Program stopped working, when tried to run
  2. What is a smart pointer and when should I use one?
  3. What exactly is nullptr?
  4. Why should I use a pointer rather than the object itself?
  5. Which kind of pointer do I use when?
  6. Why can I use auto on a private type?
  7. How much is too much with C++11 auto keyword?
  8. What is the type of lambda when deduced with “auto” in C++11?
  9. Differences between unique_ptr and shared_ptr [duplicate]
  10. Should the trailing return type syntax style become the default for new C++11 programs? [closed]
  11. What does auto&& tell us?
  12. How to return a std::string.c_str()
  13. Pointers in c++ after delete
  14. Arrow operator (->) in function heading
  15. Why does auto x{3} deduce an initializer_list?
  16. Range-for-loops and std::vector
  17. C++ auto keyword. Why is it magic?
  18. C++11 auto: what if it gets a constant reference?
  19. Constexpr pointer value
  20. Can the use of C++11’s ‘auto’ improve performance?
  21. Get pointer to object from pointer to some member
  22. What is the difference between std::reference_wrapper and a simple pointer?
  23. C++11 – declaring non-static data members as ‘auto’
  24. The new keyword “auto”; When should it be used to declare a variable type? [duplicate]
  25. Advantage of using trailing return type in C++11 functions
  26. std::unique_ptr with derived class
  27. Why does pointer to int convert to void* but pointer to function convert to bool?
  28. Why doesn’t the C++11 ‘auto’ keyword work for static members?
  29. C++11 Change `auto` Lambda to a different Lambda?
  30. what is the best modern c++ approach to construct and manipulate a 2d array [closed]

Leave a Comment