7
Yes, it is probably a weird question, but I tried a lot, and I started to think that maybe is impossible to overload this template function properly:
#include <iterator>
class Foo
{
private:
const int arr[5] = {10, 20, 30, 40, 50};
public:
const int* begin() const { return arr; }
friend auto std::begin<>(const Foo &f) -> decltype(f.begin());
}
It always throw the same error (in GCC 12.2.0):
main.cxx:10:13: error: template-id ‘begin<>’ for ‘const int* std::begin<>(const Foo&)’ does not match any template declaration
I just wanna know if is possible do things like this. Thanks.
Apparently it is impossible for this kind of functions to be defined as friends of classes:
After trying different combinations, it seems that I managed to get it working with the condition the whole template are considered friends of the class. I don't know if I should consider it a language problem, but it seems that way, since the template restrictions (in this case) are minor.
Do you think I found an error in the language?
Ah, nice idea. I've tried a few different ways of doing this, and I think what you're seeing is a discrepancy in how the compiler handles member access into incomplete types. It seems that, in your examples, the compiler is allowing
-> decltype(f.private_msg)
within the class, but I think it's not selectingdo_something
outside of it because it usesdecltype(t.private_msg)
. In my case, I'm not even able to do that within the class.For example, since I'm not able to use
decltype(f.private_msg)
inside the class, I'm usingdecltype(private_msg)
instead, which causes an error at thedo_something
declaration related to incomplete type (presumably because of thet.private_msg
usage):My reasoning is that removing the
t.private_msg
from the declaration works:The reason your second example works is because the friend template inside the class acts as a template declaration rather than a specialization, which isn't specialized until after
Foo
is complete: