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

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.