auto
auto was once introduced to circumvent complex type deductions inside template functions. Lately however many C++ guru's think that one should use it as much as possible since the compiler always deduces the correct type.
Counter arguments are as follow:
- the deduced type may be not what you want
- auto makes code harder to read.
- introduces silent bug
unwanted deduction
The canonical example of incorrect deduction is use in a for loop:
std::vector<std::string> vec;
for (auto a : vec)
{
}
Here the variable 'a' will deduced to having type std::string so that a copy of the string is made on every loop. This is sub optimal and it would be better if the type was const std::string&. This is a known idiom and people are advised to use 'const auto&' but it illustrates that blindly using auto doesn't imply 'automatic' or 'best type' always.
Another example is in the use of doubles vs floats. This can be important since there is a tradeoff between precision (double) and performance (float for GPU's).
readability
This is a personal preference. Use of auto may reduce readability. Consider the following example:
auto a = GetPerson();
From these statement alone one cannot see if the return person is a (smart) pointer, a value or something else. This makes a difference; for example in case of using it in multi threaded environments.
Consider the alternative where the type is made explicit:
std::shared_ptr<Person> ptr = GetPerson();
Its now clear that it was a pointer type and that the memory of returned object is taken care of.
Consider another case:
Person* p = GetPerson();
As a reader of the code it's clear now that one needs to question the ownership. Raw pointers are not recommended but sometimes they are unavoidable (e.g. external library like TensorRT).
The readability can somewhat mitigated by use of Hungarian notation but in case of auto it's even more dangerous that the prefix will not reflect the (deduced) type.
bugs
Previous topic already touches it. The use of auto may also coverup bugs. Recently I stumbled upon a case like this:
auto a = GetSerialize();
It turned out that this the returned object was some kind of interface (again from TensorRT) which needed to be destroyed. This was completely unnoticed until it was written out:
IHostMemory* p = GetSerialize();
conclusion
auto is a very good addition to the C++ language. It has its merit in original use case and with complex types where the actual type is not important. Iterators are a canonical example. As usual with any technique it can also hurt if you overuse it.
