C++ non-qualified lookup

I have the following code:

//mystd plays a role of the std namespace
//which does not allow any new overloads in it
//so we define one in the global namespace
namespace mystd {

template<typename T>
struct A {};


//if one uncomment this, everything works as designed
//int f(const mystd::A<int>& v);

//this some namespace which is supposed to be the main one
namespace a {

template<typename T>
int f(const T& v) {
  return 0;

template<typename T>
int operator-(const T& v) {
  return 0;


//this should be different from ::a
//so that `using namespace a;` would import global functions 
//as well as all functions from namespace a, since 
//the global namespace is the nearest common namespace
//see http://www.open-std.org/jtc1/sc22/open/n2356/dcl.html#namespace.udir 
namespace b {

template<typename T>
int Call(const T& v) {
  using namespace ::a;
  return -v + f(v);


int operator-(const mystd::A<int>&) {
  return 1;
int f(const mystd::A<int>&) {
  return 2;

int main() {
  //why this returns 1, not 3?
  //what is the difference between operator-() & f()?
  return b::Call(mystd::A<int>());

The idea is to imitate the behavior of gtest operator<< & PrintTo, so that one could overload behaviour for some std classes, which can not be done through ADL since adding anything to std namespace is not allowed. However, if I try to do it with a usual function f(), then the overload for f(mystd::A()) is considered to be defined too late (if one comments the template definition of f() the gcc gives note: β€˜int f(const mystd::A<int>&)’ declared here, later in the translation unit)

The question is why the behaviour is different for operator-() and f()?

Source: c++

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.