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

by

I think that one should use the auto keyword whenever it’s hard to say how to write the type at first sight, but the type of the right hand side of an expression is obvious. For example, using:

my_multi_type::nth_index<2>::type::key_type::composite_key_type::
    key_extractor_tuple::tail_type::head_type::result_type

to get the composite key type in boost::multi_index, even though you know that it is int. You can’t just write int because it could be changed in the future. I would write auto in this case.

So if the auto keyword improves readability in a particular case then use it. You can write auto when it is obvious to the reader what type auto represents.

Here are some examples:

auto foo = std::make_shared<Foo>();   // obvious
auto foo = bla();                     // unclear. don't know which type `foo` has

const size_t max_size = 100;
for ( auto x = max_size; x > 0; --x ) // unclear. could lead to the errors
                                      // since max_size is unsigned

std::vector<some_class> v;
for ( auto it = v.begin(); it != v.end(); ++it )
                                      // ok, since I know that `it` has an iterator type
                                      // (don't really care which one in this context)

More Related Contents:

  1. C++ auto keyword. Why is it magic?
  2. Why can I use auto on a private type?
  3. Converting std::__cxx11::string to std::string
  4. What is the type of lambda when deduced with “auto” in C++11?
  5. Should the trailing return type syntax style become the default for new C++11 programs? [closed]
  6. What does auto&& tell us?
  7. decltype and parentheses
  8. Arrow operator (->) in function heading
  9. Why does auto x{3} deduce an initializer_list?
  10. Range-for-loops and std::vector
  11. C++11 auto: what if it gets a constant reference?
  12. Can the use of C++11’s ‘auto’ improve performance?
  13. What are declarations and declarators and how are their types interpreted by the standard?
  14. Inferring the call signature of a lambda or arbitrary callable for “make_function”
  15. C++11 – declaring non-static data members as ‘auto’
  16. `auto` specifier type deduction for references
  17. The new keyword “auto”; When should it be used to declare a variable type? [duplicate]
  18. Advantage of using trailing return type in C++11 functions
  19. Why doesn’t the C++11 ‘auto’ keyword work for static members?
  20. C++11 Change `auto` Lambda to a different Lambda?
  21. Does ‘auto’ type assignments of a pointer in c++11 require ‘*’?
  22. Why is conversion from string constant to ‘char*’ valid in C but invalid in C++
  23. Pretty-print std::tuple
  24. What does “default” mean after a class’ function declaration?
  25. Creating an array initializer from a tuple or variadic template parameters
  26. Why is std::function not equality comparable?
  27. How to make a variadic macro for std::cout?
  28. Where is shared_ptr?
  29. std::thread::join() hangs if called after main() exits when using VS2012 RC
  30. How to get duration, as int milli’s and float seconds from ?

Leave a Comment