In which access control context are concepts evaluated?

by

First, let’s start with requires expressions. The section on the behavior of a requires expression has nothing special to say about the access controls of its component expressions. Similarly, the section on access controls says nothing in particular about requires expressions. In particular, there is [class.access]/4, which says:

Access control is applied uniformly to all names, whether the names are referred to from declarations or expressions.

Given this, it seems quite clear that requires expressions don’t need special rules. If you use a requires expression in a context which has access to some name, then the requires expression has access to that name. Otherwise, it cannot access the name.

So what of concepts themselves? Well, that’s simple. [temp.concept]/3 tells us:

A concept-definition shall appear at namespace scope.

concepts are therefore global definitions; they can’t be members of a class. So they cannot have access due to being a class member. friend can only specify functions or classes, and concepts are neither. So a concept cannot have access due to being a friend.

concepts are evaluated using special logic, defined in [temp.names]/8:

A concept-id evaluates to true if the concept’s normalized constraint-expression is satisfied ([temp.constr.constr]) by the specified template arguments and false otherwise.

There is nothing in the rules laid down in [temp.constr.constr] which gives such evaluation any special access controls.

Therefore, any requires expressions used as part of a concept declaration use the global context for determining whether they can access names. That is, they can only ever use public interfaces.

More Related Contents:

  1. Can I take the address of a function defined in standard library?
  2. Why does same_as concept check type equality twice?
  3. Can class template constructors have a redundant template parameter list in c++20
  4. Class type non-type template parameter initialization does not compile
  5. Why do we require requires requires?
  6. Will consteval functions allow template parameters dependent on function arguments?
  7. Does constraint subsumption only apply to concepts?
  8. C++ Concept that requires a member function with an OutputIterator as parameter
  9. Familiar template syntax for generic lambdas
  10. Is lambdification of a concept an improvement or bad practice?
  11. Why don’t I need to specify “typename” before a dependent type in C++20?
  12. Order of evaluation of arguments using std::cout
  13. Take the address of a one-past-the-end array element via subscript: legal by the C++ Standard or not?
  14. Do distinct functions have distinct addresses?
  15. Why class data members can’t be initialized by direct initialization syntax?
  16. Is adding to a “char *” pointer UB, when it doesn’t actually point to a char array?
  17. Is a pointer with the right address and type still always a valid pointer since C++17?
  18. Pure virtual functions may not have an inline definition. Why?
  19. Is most vexing parse a formally defined concept
  20. Pseudo-destructor call does not destroy an object
  21. Why is a constexpr function on a reference not constexpr?
  22. Why is volatile deprecated in C++20?
  23. Classes with both template and non-template conversion operators in the condition of switch statement
  24. Why default three-way operator (spaceship ) generates equality operator (==) and user define three-way operator not?
  25. Why do (only) some compilers use the same address for identical string literals?
  26. Do C++ enums Start at 0?
  27. Can we apply content not explicitly cited from the normative references to the C++ standard?
  28. C++ operator % guarantees
  29. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?
  30. Will consteval allow using static_assert on function arguments?

Leave a Comment