Does a declaration using “auto” match an extern declaration that uses a concrete type specifier?

by

There’s surprisingly little in the standard about this. About all we hear about redeclaration is:

[C++11: 3.1/1]: A declaration (Clause 7) may introduce one or more names into a translation unit or redeclare names introduced by previous declarations. [..]

and the only relevant part of auto‘s semantics:

[C++11: 7.1.6.4/3]: Otherwise, the type of the variable is deduced from its initializer. [..]

(reminding us that the type of x is int).

We know that a variable must be given the same type by all declarations:

[C++11: 3.5/10]: After all adjustments of types (during which typedefs (7.1.3) are replaced by their definitions), the types specified by all declarations referring to a given variable or function shall be identical, except that declarations for an array object can specify array types that differ by the presence or absence of a major array bound (8.3.4). A violation of this rule on type identity does not require a diagnostic.

and the “after all adjustments of types” ought to take care of any questions regarding auto‘s participation in all of this; my interpretation, then, is that this is inherently a valid redeclaration (and definition) of the x at global scope with type int, and that Clang is correct. Even if we propose that auto does not count as “adjustment of type”, since no diagnostic is required, at worst all listed implementations are compliant in their own way.

I believe GCC and Visual Studio are taking the following as inspiration:

[C++11: 7.1.6.4/5]: A program that uses auto in a context not explicitly allowed in this section is ill-formed.

…but I think that this is short-sighted. It seems unlikely that the standard language is intended to prohibit the usual redeclaration rules, just because they are not repeated or explicitly referenced from within 7.1.6.4.

C++14 adds wording that relates to declarations of functions with deduced types:

[C++14: 7.1.6.4/13]: Redeclarations or specializations of a function or function template with a declared return type that uses a placeholder type shall also use that placeholder, not a deduced type. [..]

By symmetry one might suggest that, in your int case, it is intended that GCC and VS be correct in rejecting the program. However, this is a different feature (since deduction cannot be applied to mere declarations) and thus a different scenario.

Either way, improved standard wording would help here. I consider it a [reasonably minor] editorial defect.

More Related Contents:

  1. using extern template (C++11)
  2. Will std::string always be null-terminated in C++11?
  3. What does extern inline do?
  4. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  5. int a[] = {1,2,}; Why is a trailing comma in an initializer-list allowed?
  6. Is passing a C++ object into its own constructor legal?
  7. Is the behaviour of i = i++ really undefined?
  8. About binding a const reference to a sub-object of a temporary
  9. Explicit specialization in non-namespace scope does not compile in GCC
  10. Aliasing T* with char* is allowed. Is it also allowed the other way around?
  11. Does this really break strict-aliasing rules?
  12. So why is i = ++i + 1 well-defined in C++11?
  13. Does the behavior of guaranteed copy elision depend on existence of user-defined copy constructor?
  14. When do extra parentheses have an effect, other than on operator precedence?
  15. What is the difference between C++03 `throw()` specifier and C++11 `noexcept`?
  16. Familiar template syntax for generic lambdas
  17. Legal to overwrite std::string’s null terminator?
  18. ‘auto’ as a template argument placeholder for a function parameter
  19. Why do (only) some compilers use the same address for identical string literals?
  20. Do C++ enums Start at 0?
  21. Calling an explicit constructor with a braced-init list: ambiguous or not?
  22. Can we apply content not explicitly cited from the normative references to the C++ standard?
  23. Calling delete on NULL pointers – C++03 vs C++11
  24. C++ operator % guarantees
  25. std::tuple memory alignment
  26. Appending std::vector to itself, undefined behavior?
  27. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?
  28. using extern template (C++11) to avoid instantiation
  29. What is use of the ref-qualifier `const &&`?
  30. Is char default-promoted?

Leave a Comment