Getting the address of an inline defined friend function - c++

Question

Consider the following code:
#include <iostream>
struct foo {
friend void bar(foo) {}
void foobar() {
std::cout << &bar << '\n'; // error
}
};
int main() {
bar(foo{}); // ok, visible through ADL
foo{}.foobar();
}
gcc gives me this error:
main.cpp: In member function 'void foo::foobar()':
main.cpp:7:23: error: 'bar' was not declared in this scope
std::cout << &bar << '\n'; // error
^~~
That's because bar is a friend function defined in the class itself, making it invisible in the global namespace. The only way to access it is through ADL, but I have not found a way to use ADL to get the address of bar.
So my question is, how can I take the address of bar? Is there any other way than to define bar outside of foo?

Answer 1

You could declare the friend function in the enclosing namespace scope in a different translation unit:
In foo.hpp:
#include <iostream>
struct foo;
void (*get_bar_address())(foo);
struct foo {
friend void bar(foo) {}
void foobar() {
std::cout << get_bar_address() << '\n'; // no error
}
};
In foo.cpp
#include "foo.hpp"
void bar(foo);
void (*get_bar_address())(foo){
return bar;
}

Answer 2

It seems to be impossible to get exactly what you want. The problem is that an inline friend declared function will only be found by argument-dependant lookup, as defined in the C++ standard 11 and 14 in
7.3.1.2
3 Every name first declared in a namespace is a member of that namespace. If a friend declaration in a non-local class first declares a class or function the friend class or function is a member of the innermost enclosing namespace. The name of the friend is not found by unqualified lookup (3.4.1) or by qualified lookup (3.4.3) until a matching declaration is provided in that namespace scope (either before or after the class definition granting friendship). If a friend function is called, its name may be found by the name lookup that considers functions from namespaces and classes associated with the types of the function arguments (3.4.2). If the name in a friend declaration is neither qualified nor a template-id and the declaration is a function or an elaborated-type-specifier, the lookup to determine whether the entity has been previously declared shall not consider any scopes outside the innermost enclosing namespace.
That means it is only ever be found by argument dependent lookup. Revising the rules, argument dependent lookup is only applied within a function call expression. Hence you will not be able to retrieve the address of the function as any such an expression will evaluate to the result of the call.
In case you only need a pointer referring to a function with the same functionality as bar, you could however utilize lambdas to get a pointer to such a function nevertheless.
void foo::foobar() {
using fntype = void(*)(foo);
std::cout << (fntype)[](foo f){ bar(f); } << '\n'; // error
}
The downside is that any other lambda will likely result in an intirely different address. You could however offer the address in a different (static) member function if the uniqueness is of importance.

Answer 3

Did you try something like this? I find it interesting that you would declare a friend function from inside the scope of the struct/class but hey.
#include <iostream>
// forward declare foo so you can forward declare bar :)
struct foo;
// forward declare bar so an address is available on the line that references it.
void bar(foo);
struct foo
{
friend void bar(foo)
{
std::cout << "bar called" << std::endl;
}
void foobar()
{
std::cout << "address of bar " << &bar << '\n'; // error
}
};
int main()
{
bar(foo{}); // ok, visible through ADL
foo{}.foobar();
}
Tried it and it works LOL not sure why:
$ ./test.exe
bar called
address of bar 1
though address of 1 is suspicious. :) but hey it compiled and did something. maybe you can take it further or someone can explain why this compiled/worked in the first place.