Why do the usual access control checking applies to names used to specify explicit instantiation when accessed through template parameters?

by

Explicit instantiations have to be at namespace scope, which means private members of classes would not normally be accessible. Without the rule you quote, this would be impossible:

class Foo
{
private:
  struct Bar;

  template<typename T> class Baz { };

public:
  void f();  // does things with Baz<Bar>
};

// explicit instantiation declaration
extern template class Foo::Baz<Foo::Bar>;

Without that rule, I would not be able to name Foo::Bar or even Foo::Baz at namespace scope, because those names are private to Foo.

Since I’m not actually using Foo::Bar or Foo::Baz here, just referring to their names to tell the compiler I’m instantiating the template somewhere else, there is no real access violation (although it is possible to use this rule to perform a very sneaky trick not possible otherwise).

Similarly, when I write the explicit instantiation definition in some other file, I need to be able to refer to the private names again at namespace scope.

More Related Contents:

  1. Explicit specialization in non-namespace scope [duplicate]
  2. C++ syntax for explicit specialization of a template function in a template class?
  3. “invalid use of incomplete type” error with partial template specialization
  4. explicit specialization of template class member function
  5. Explicit specialization in non-namespace scope does not compile in GCC
  6. C++ : friend declaration ‘declares a non-template function
  7. Template instantiation details of GCC and MS compilers
  8. Is there a compiler bug exposed by my implementation of an is_complete type trait?
  9. gcc can compile a variadic template while clang cannot
  10. Can we see the templates instantiated by the C++ compiler?
  11. C++11 does not deduce type when std::function or lambda functions are involved
  12. Why can’t the template argument be deduced when it is used as template parameter to another template?
  13. c++ virtual inheritance
  14. GCC and Precompiled Headers
  15. Explicit template instantiation – when is it used?
  16. Accessing inherited variable from templated parent class [duplicate]
  17. SFINAE to check for inherited member functions
  18. When to use std::forward to forward arguments?
  19. Efficient 128-bit addition using carry flag
  20. Is there a compiler hint for GCC to force branch prediction to always go a certain way?
  21. C++ static template member, one instance for each template type?
  22. Can the point-of-instantiation be delayed until the end of the translation unit?
  23. Where does gcc look for C and C++ header files?
  24. How to pass a template function in a template argument list
  25. How to make std::make_unique a friend of my class
  26. Template Function Specialization for Integer Types
  27. counting the number of lines in a text file
  28. Should std::unique_ptr be permitted
  29. How to check if a template parameter is an iterator type or not?
  30. Will I be able to declare a constexpr lambda inside a template parameter?

Leave a Comment