Why can't friend function be recognized with using directive vs enclosing in namespace?

Question

Why can't the friend operator<< be recognized when defined in the cpp file and a using directive? I have in header file, game.h

namespace uiuc {

class Game {
public:
  Game();
  void solve();

  friend std::ostream & operator<<(std::ostream & os, Game & game);

private:
  std::vector<Stack> stacks;
};

And in my cpp file, game.cpp:

#include "game.h"

using namespace  uiuc;
std::ostream & operator<<(std::ostream & os, Game & game) {
  for (unsigned long i = 0; i < game.stacks.size(); ++i) {
    os << "Stack [" << i << "]: " << game.stacks[i] << std::endl;
  }

  return os;
}

The error I get is:

g++ -std=c++1z -g -Wfatal-errors -Wall -Wextra -pedantic -MMD -MP  -c game.cpp
game.cpp:5:38: fatal error: 'stacks' is a private member of 'uiuc::Game'
  for (unsigned long i = 0; i < game.stacks.size(); ++i) {
                                     ^
./game.h:17:22: note: declared private here
  std::vector<Stack> stacks;
                     ^
1 error generated.
make: *** [Makefile:18: game.o] Error 1

This worked when the friend function was defined in the header file. I decided to move it since I was getting a linker error for a duplicate symbol for the same method so I decided to see what would happen if I moved the function definition to the cpp file. What am I missing? However when I enclose the definition within the namespace uiuc, it removes this error and I am back to the linker error. The linker error is NOT what this question is about.

Why can't the compiler not realize that this is a friend function and so can access the private variables?

The fix is simple: Just enclose your definition in `namespace uiuc {` and `}`. IMHO, that's very usual. ;-) I stronly believe the operator definition is placed in global namespace (ignoring the `using namespace uiuc` and the `friend` declaration). Hence, the `friend` declaration in `uiuc::Game` is unrelated. — Scheff's Cat, Mar 20 '20 at 13:03
You cannot define a function in a namespace using `using`. If you had `namespace uiuc {void foo();}` then you can't define it with `using namespace uiuc; void foo() {...}` — user253751, Mar 20 '20 at 13:06
FYI: [SO: Why would a struct need a friend function?](https://stackoverflow.com/a/52370542/7478597) — Scheff's Cat, Mar 20 '20 at 13:09
If you want to keep it in the header file which means stopping the duplicate include warning simply make the function inline. — andre, Mar 20 '20 at 13:25
@andre, inline solves the issue. But from what I have read, it is up to the compiler to decide to inline the function. What if it doesn't? — heretoinfinity, Mar 20 '20 at 13:52
@heretoinfinity The `inline` keyword has nothing directly to do with whether functions are inlined. The actual meaning of the `inline` keyword is related to whether function definitions can (or must) be repeated in multiple translation units. See my answer. — walnut, Mar 20 '20 at 13:54

walnut · Accepted Answer · 2020-03-20T13:58:34.813

Functions first declared as friend in a class are placed in the enclosing namespace, so the function you want to define must be defined in the uiuc namespace.

You might be under assumption that if you use using namespace uiuc; new declarations/definitions will be placed into the uiuc namespace, but that is not the case. using namespace only affects the lookup of names, not where declarations/definitions are placed.

Therefore the function you are defining at the moment is operator<<(std::ostream & os, uiuc::Game & game) in the global namespace scope (which is not a friend of uiuc::Game), not operator<<(std::ostream & os, Game & game) in the uiuc namespace.

So you need to open the namespace properly:

#include "game.h"

namespace uiuc {
  std::ostream & operator<<(std::ostream & os, Game & game) {
    for (unsigned long i = 0; i < game.stacks.size(); ++i) {
      os << "Stack [" << i << "]: " << game.stacks[i] << std::endl;
    }

    return os;
  }
}

Also, regarding the linker error: If you define the friend function outside the class definition and you don't specify it as inline, then it will be a non-inline function, meaning that there may be only one definition for it in only one translation unit. This typically precludes putting the definition in the header, because the header is usually included in multiple translation units.

If you define the function inside the class body or declare it with the inline keyword, then it will be an inline function, meaning that it has to be defined in every translation unit using it, which usually means that the definition must be placed in the header file.

Why can't friend function be recognized with using directive vs enclosing in namespace?

1 Answers1