Non understood template and accessibility behavior - c++

Question

In any case, A::Stuff is protected, so why inheriting from A and forcing its members' accessibility to protected resulting in an error ?
class A {
protected:
template <typename T>
static void Stuff() {
T::template Stuff<T>();
}
};
class B : protected A {
public:
void something() { A::Stuff<B>(); }
// I have these two, inelegant workarounds:
// using A::Stuff; // KO: This is wrong, it changes the accessibility of Stuff.
// class B : public A // KO: Accessibility changed.
// friend A; // OK: This seems fine.
};
int main() {
B b;
b.something();
}
Code available at: https://godbolt.org/z/r1Ya3rzsK
Assuming the classes A and B as defined above clang and gcc will give you something like that:
'Stuff' is a protected member of 'A'
T::template Stuff<T>();
I give a workaround in the comment and more are welcome as long as the members' accessibility is not changed.

Answer 1

The problem is that the A::Stuff<B>() will call T::Stuff<T>() with T=B aka B::Stuff<B>(). B doesn't have a Stuff function, so it will try falling back to A::Stuff which is invalid, as you made the inheritance protected. (btw if it was valid, because the inheritance was public that would lead to an infinite recursion).
I think you don't want an infinite recursion here. If you want Stuff<B> to be valid add a Stuff function to B.
#include <iostream>
class A {
protected:
template <typename T>
static void Stuff() {
std::cout<<"called A\n";
T::template Stuff<T>();
}
};
class B : protected A {
public:
void something() { A::Stuff<B>(); }
template <typename T>
static void Stuff() {
std::cout<<"called B\n";
//...
}
// I have these two, inelegant workarounds:
// using A::Stuff; // KO: This is wrong, it changes the visibility of Stuff.
// class B : public A // KO: Visibility changed.
// friend A; // OK: This seems fine.
};
int main() {
B b;
b.something();
}