What does it mean when you declare a friend and then define it inside a class?

Question

I'm trying to understand a code snippet that I've managed to make work by trial and error. I understand everything about this snippet except why it doesn't work when I take "friend" out of the class declaration. I don't understand what friend is doing in this context.

stringstream log;

class logWrapper {
    friend ostream& operator<<(ostream& os, logWrapper& thislogend)
        {
        stringstream &ss = dynamic_cast(os);
        // This line replaced with printf for clarity
        // The actual code sends the C style string to a
        // legacy logging system that only takes C style strings
        // _log(LOG_ERR, "%s", ss.str().c_str());
        printf("%s\n", ss.str().c_str());

    ss.str("");
    return os;
    }
} logend;

int main(void)
{
log << "This is a test" << logend;
}

Answer 1

You are simultaneously declaring and defining a friend function, which overloads an operator.

Functions which are declared as friend can access all the private members of any instance of the class which befriended them.

This is different from regular member functions (which can obviously also access private members), since friend functions are not members of the class -- they are stand-alone functions.

So since you've defined the stand-alone function inside the class, it appears confusing at first glance -- just remember that it's not really a member function at all.

Answer 2

It means that the friend is not a member of the class, but you can access static class members and member types (including private ones) without qualification.

This makes the function "look and feel" like a member. Because operator<< here is intimately tied to the logWrapper, it is intuitive that you can implement it as if it were a member of the class.

But remember, it is not a member! It is just a free function with special access privileges, just as if it were defined outside.

Edit: Since there are no static members and no member types, this happens not to make a difference here. You could move the definition of the friend outside without changing it. This style is idiomatic, though, because you could. Often it is used with templates, which often do have member types/typedefs.

Indeed, defining a friend inside a template<…> class block is the only way to define a templated non-template function. This esoteric and sometimes-elusive beast is nonetheless sometimes very convenient to have around. Usually his creation is accidental, even serendipitous, so I won't get into that discussion…