Friendship problems when overriding operator<<

Question

I'm trying to overload operator<< in the standard way. I have a class called SymbolTable residing in a file called SymbolTable.h as follows:

namespace Compaler // It's a pun; don't ask
{

class SymbolTable
{
public:
  // ...
  friend ostream& operator<<(ostream &out, const SymbolTable &table);
private:
  vector<map<int, Symbol*> > mSymbols;
};

// ...

}

The implementation of operator<< accesses some private members of SymbolTable. Here is the signature of the implementation, to demonstrate that it does not differ from the signature of the forward declaration (I copy-pasted it to be sure I wasn't going crazy.)

ostream& operator<<(ostream &out, const SymbolTable &table)
{ ... }

If I put the implementation in SymbolTable.h where the second ... is, I get the following linker error:

ld: duplicate symbol Compaler::operator<<(std::basic_ostream >&, Compaler::SymbolTable const&)in /var/folders/kt/pl6qd1490fn3yqxfpg64jyr80000gn/T//ccstrYnU.o and /var/folders/kt/pl6qd1490fn3yqxfpg64jyr80000gn/T//ccDQFiyK.o for architecture x86_64

However, if I instead put it in SymbolTable.cpp, where the rest of my SymbolTable member implementations are, the code won't even compile; I get errors related to accessing private members, indicating that the friendship is not being recognized:

../SymbolTable/SymbolTable.h: In function ‘std::ostream& operator<<(std::ostream&, const Compaler::SymbolTable&)’: ../SymbolTable/SymbolTable.h:75: error: ‘std::vector, std::allocator >, Compaler::Symbol*, std::less, std::allocator > >, std::allocator, std::allocator >, Compaler::Symbol*> > >, std::allocator, std::allocator >, Compaler::Symbol*, std::less, std::allocator > >, std::allocator, std::allocator >, Compaler::Symbol*> > > > > Compaler::SymbolTable::mSymbols’ is private ../SymbolTable/SymbolTable.cpp:98: error: within this context

What am I doing wrong?

Summary of answers:

Thanks to Seth Carnegie and Daniel R. Hicks, I've got it figured out. For the benefit of anyone who might make the same mistakes in the future, I'm going to summarize the answers in my question because there was a lot of back and forth in the comments.

The first (duplicate symbol when the implementation was in SymbolTable.h) problem occurred because I was trying to simultaneously compile and link two files which included SymbolTable.h . I have been labouring under a misunderstanding of how #ifdef include guards work; that is, they will only prevent code from being included twice in one file, but will not help you if you try to link two files which both included code from a third.

The second problem was that I forgot to put my operator<< implementation in the Compaler namespace when I had it in the SymbolTable.cpp file.

Answer 1

If you do it in the header file you need to use inline:

namespace Compaler // It's a pun; don't ask
{    
    class SymbolTable
    {
        public:
            friend ostream& operator<<(ostream &out, const SymbolTable &table);
        private:
            vector<map<int, Symbol*> > mSymbols;
    };

    inline ostream& operator<<(ostream &out, const SymbolTable &table)
    {
         out << table[0].something;
         return out;
    }
}

If you want to do in the source file. Then the operator<< must be declared in the namespace

Header.h

namespace Compaler // It's a pun; don't ask
{    
    class SymbolTable
    {
        public:
            friend ostream& operator<<(ostream &out, const SymbolTable &table);
        private:
            vector<map<int, Symbol*> > mSymbols;
    };
    ostream& operator<<(ostream &out, const SymbolTable &table);
}

Source.cpp

#include "Header.h"
namespace Compaler   // must be here
{    
    ostream& operator<<(ostream &out, const SymbolTable &table)
    {
         out << table[0].something;
         return out;
    }
}

Answer 2

The first problem is because you're putting the definition in the header file and #includeing it twice. This causes a multiple definition error.

As for the second problem, probably your function has a different signature than the friend declaration.

Just to let you know, as an alternative to getting the signature right, you can write the function inline:

class SymbolTable
{
public:
  // ...
  friend ostream& operator<<(ostream &out, const SymbolTable &table) {
      ...
  }
private:
  vector<map<int, Symbol*> > mSymbols;
};

Edit: Since apparently the signature is right, the error lies somewhere else. You'll have to post more code.

Answer 3

As other answers and comments have pointed out, it is possible to do this as a friend function. However, an alternative I often prefer is to make a public print function, which prints the object to an std::ostream, and then let operator<< call that function. This lets you avoid breaking encapsulation by making operator<< a friend function:

namespace Compaler // It's a pun; don't ask
{

class SymbolTable
{
public:
  // ...
  void print(ostream & out); // basically your definition of operator<<, in your .cpp file
private:
  vector<map<int, Symbol*> > mSymbols;
};

// this doesn't have to be inline, but since it's a two-liner, there's probably no harm either
inline ostream& operator<<(ostream &out, const SymbolTable &table)
{
    table.print(out);
    return out;
}

// ...

}

This also gives your clients the option to avoid the << syntax, which may or may not be a good thing.

Another trick: if you do this for multiple classes, you could make operator<< a template, so that any type implementing print(ostream&) can be output to a stream:

template <typename T>
inline ostream& operator<<(ostream &out, const T &obj)
{
    obj.print(out);
    return out;
}

Since this is a template function, any specific definitions of it for a class will override this definition, and classes that don't define print(ostream&) are fne as long as they are never output to a stream, since this function will never be instantiated in that case.