5

When compiling C++, gcc and clang seems to postpone the type-checking of template instantiations until after all declarations of the program have been processed. Is this guaranteed in the language?

To elaborate, I can keep a type incomplete at the point where a template is defined or a template instantiation is needed, as long as I complete the type somewhere later in the program:

class A;
class B;

extern A* pa;

// 1. template definition
template<typename T>
T* f() { return static_cast<T*>(pa); }

// 2. template instantiation
B* test() { return f<B>(); }

// 3. completing types
class A { };
class B : public A { };

Note that the definitions of A and B are required to type check the template instantiation (to make the static_cast valid). If you leave out step 3, step 2 will no longer compile.

In the organisation of my headers, can I rely that this order will be accepted by any standard C++ compiler?

Bruno De Fraine
  • 45,466
  • 8
  • 54
  • 65
  • See also http://stackoverflow.com/questions/7210286/ – aschepler Dec 10 '15 at 14:46
  • 2
    End of the translation unit is also considered a point of instantiation. see [can-the-point-of-instantiation-be-delayed-until-the-end-of-the-translation-unit](http://stackoverflow.com/questions/23030403/can-the-point-of-instantiation-be-delayed-until-the-end-of-the-translation-unit) – Jarod42 Dec 10 '15 at 14:46
  • This doesn't work anymore if `f` uses automatic type deduction: http://stackoverflow.com/q/34207433/2805305 – bolov Dec 10 '15 at 16:53

1 Answers1

5

The rule is called "two-phase name lookup".

The names, which are not dependant on the template parameters, are looked up and checked at definition, and the dependent names are checked at the point of instantiation.

For your example, there is one important detail: the end of translation unit is also considered a point of instantiation for function templates:

C++14 N4140 14.6.4.1 [temp.point] P8:

A specialization for a function template, a member function template, or of a member function or static data member of a class template may have multiple points of instantiations within a translation unit, and in addition to the points of instantiation described above, for any such specialization that has a point of instantiation within the translation unit, the end of the translation unit is also considered a point of instantiation.

Thus, although the type is incomplete at point "2", where explicit instantiation happens, it is complete at the end of file, which makes the template instantiation legitimate.

Note: Microsoft compiler does not implement this rule in full, violating the standard. In Microsoft compiler, all the lookup happens at the point of instantiation (thus the example should also work, but I don't have access to MSVC to check). Other major compilers do implement this rule correctly.

Ilya Popov
  • 3,765
  • 1
  • 17
  • 30
  • 1
    Two-phase lookup does not explain the behavior (which I also observe with MSVC by the way), but the rest of your answer does: some compilers postpone the point-of-instantiation until end of translation unit, and C++14 allows this. But from the specification, I understand that a compiler may also choose one of the other points-of-instantiation earlier in the translation unit, for example, at step 2. So a standard-conformant compiler could both accept or reject this code, right? – Bruno De Fraine Dec 11 '15 at 08:17