Is C 11's `auto` Keyword Overused: When Should You Avoid Explicit Typing?

Is C 11's Auto Keyword Overkill?

While the auto keyword has proven invaluable in handling complex templated types, as intended by its designers, concerns arise over its overuse in simpler scenarios. Should auto be used to avoid explicitly stating types, even for straightforward expressions like std::make_shared()?

Intended Use and Practical Guidelines

According to the C standard committee, auto should be employed when explicitly stating the type is challenging but the type of the right-hand side is evident. For example, consider the following code:

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

Retrieving the composite key type in boost::multi_index requires this complex expression. Even though the type is known to be int, auto should be used to enhance readability in such cases.

Recommended Use Cases

Use auto when:

• The reader can easily infer the type represented by auto.
• The type is obvious on the right-hand side of the expression.
• It improves readability and prevents unnecessary repetition.

Examples

• Using auto in std::make_shared() is appropriate because the type is evident.
• In the expression bla(), where bla() returns a shared_ptr, using auto is unclear as the type of foo is uncertain.
• Using auto in a loop where the iterator type is known but not the specific iterator, such as auto it = v.begin();, can enhance code clarity.

Cautionary Tales

• Explicitly specifying the type aids in documentation and sanity checks.
• Be cautious when using auto for loops with unsigned variables, as it can lead to unexpected errors.

The above is the detailed content of Is C 11's `auto` Keyword Overused: When Should You Avoid Explicit Typing?. For more information, please follow other related articles on the PHP Chinese website!