Can SFINAE detect private access violations?

by

Yes.

EDIT: C++11 Standard quote from §14.8.2 [temp.deduct]

8/ If a substitution results in an invalid type or expression, type deduction fails. An invalid type or expression is one that would be ill-formed if written using the substituted arguments. [ Note: Access checking is done as part of the substitution process. —end note ]

This suggests to me that private can trigger an SFINAE error. Reading on:

Only invalid types and expressions in the immediate context of the function type and its template parameter types can result in a deduction failure. [ Note: The evaluation
of the substituted types and expressions can result in side effects such as the instantiation of class template specializations and/or function template specializations, the generation of implicitly-defined functions, etc. Such side effects are not in the “immediate context” and can result in the program being ill-formed.—end note ]

The “immediate context” is not so clear to me… but it does not contradict my point 🙂

end of EDIT

So it seems to me that it will error out in an SFINAE way, this is further confirmed by this excerpt from Clang:

// clang/Basic/DiagnosticIDs.h:185-209

  /// \brief Enumeration describing how the the emission of a diagnostic should
  /// be treated when it occurs during C++ template argument deduction.
  enum SFINAEResponse {
    /// \brief The diagnostic should not be reported, but it should cause
    /// template argument deduction to fail.
    ///
    /// The vast majority of errors that occur during template argument
    /// deduction fall into this category.
    SFINAE_SubstitutionFailure,

    /// \brief The diagnostic should be suppressed entirely.
    ///
    /// Warnings generally fall into this category.
    SFINAE_Suppress,

    /// \brief The diagnostic should be reported.
    ///
    /// The diagnostic should be reported. Various fatal errors (e.g.,
    /// template instantiation depth exceeded) fall into this category.
    SFINAE_Report,

    /// \brief The diagnostic is an access-control diagnostic, which will be
    /// substitution failures in some contexts and reported in others.
    SFINAE_AccessControl
  };

There are special cases with regard to Access Control in the case of SFINAE.

More Related Contents:

  1. What exactly is the “immediate context” mentioned in the C++11 Standard for which SFINAE applies?
  2. Templated check for the existence of a class member function?
  3. How does `void_t` work
  4. What happens if you static_cast invalid value to enum class?
  5. Will std::string always be null-terminated in C++11?
  6. SFINAE working in return type but not as template parameter
  7. Is passing a C++ object into its own constructor legal?
  8. How to write a type trait `is_container` or `is_vector`?
  9. Detecting constexpr with SFINAE
  10. std::ignore with structured bindings?
  11. Template specialization and enable_if problems [duplicate]
  12. Select class constructor using enable_if
  13. Why is it not possible to overload class templates?
  14. treating memory returned by operator new(sizeof(T) * N) as an array
  15. Is circumventing a class’ constructor legal or does it result in undefined behaviour?
  16. Static member access in constant expressions
  17. Why is f(i = -1, i = -1) undefined behavior?
  18. Why is the std::initializer_list constructor preferred when using a braced initializer list?
  19. Why does `int ;` compile fine in C, but not in C++?
  20. What happened to the “aggregate or union type that includes one of the aforementioned types” strict aliasing rule?
  21. Can I Reference Previous Members of an Initializer List?
  22. Does this code from “The C++ Programming Language” 4th edition section 36.3.6 have well-defined behavior?
  23. Are int8_t and uint8_t intended to be char types?
  24. Why doesn’t an if constexpr make this core constant expression error disappear?
  25. Use of typename keyword with typedef and new
  26. Lifetime of object is over before destructor is called?
  27. Are pointers to non-static member function “formally” not considered pointers
  28. Directly write into char* buffer of std::string
  29. C++11 cross compiler/standard library random distribution reproducibility
  30. How do we use void_t for SFINAE?

Leave a Comment