operator << argument-dependent lookup does not look in global namespace

Question

In the following scenario, inside function(), on line ss << bb, I get an error:

binary '<<': no operator found which takes a right-hand operand of type 'CommonType' (or there is no acceptable conversion) error.

My ADL understanding is that it will look into the current namespace (that is AppNamespace::InnerNamespace) and since no operator << is found, it will look into the namespace of the arguments and as the CommonType is in global namespace I would expect that the operator << defined in the CommonTypes.h to be found. Obviously my understanding is wrong. Can anyone figure out how this should be working?

Main.cpp

namespace AppNamespace
{

    typedef std::vector<std::string> OtherType;

    std::ostream& operator << (std::ostream& os, const OtherType& ot)
    {
        for (auto& el : ot)
        {
            os << el;
        }
        return os;
    }

    namespace InnerNamespace
    {
        void function()
        {
            CommonType bb;
            std::stringstream ss;
            ss << bb;
        }
    }
}


int main()
{
    AppNamespace::InnerNamespace::function();
    return 0;
}

CommonTypes.h:

    #pragma once

#include <vector>

typedef std::vector<uint8_t> CommonType;

std::ostream& operator << (std::ostream& os, const CommonType& bb)
{
        for (auto& el : bb)
        {
            os << el;
        }
        return os;
}

Even without the alias problem, your understanding of [ADL](http://en.cppreference.com/w/cpp/language/adl) is wrong. overloads of the namespace of argument are considered even is one exists at global namespace. We first build the set of namespace to consider. — Jarod42, May 09 '18 at 16:54

score 1 · Answer 1 · answered May 09 '18 at 15:55

1

The problem here is that ADL lookup will be performed in std namespace and namespace where CommonType is declared is not relevant, so in order to make this work you need to place operator << in appropriate namespace:

namespace std
{

ostream& operator << (ostream& os, const CommonType& bb)
{
    for (auto& el : bb)
    {
        os << el;
    }
    return os;
}

}

answered May 09 '18 at 15:55

user7860670

35,849
4
58
84

2

Isn't adding to namespace std UB? http://en.cppreference.com/w/cpp/language/extending_std – Paul Floyd May 09 '18 at 16:03
@PaulFloyd Not necessary, sometimes it is a proper way of utilizing standard library, for example `std::is_error_code_enum` or `std::default_delete` specializations. – user7860670 May 09 '18 at 16:08
that is mentioned in the link, partial specializations are allowed, declarations and full specializations not allowed. – Paul Floyd May 09 '18 at 16:10
@PaulFloyd That article is somewhat incomplete. `std::is_error_code_enum` is an example of allowed full specialization. In case of `operator <<` we can not place it anywhere else because ADL lookup will be performed in `std` namespace since both arguments are from `std` namespace. see [similar question - Where should I define operator >> for my specialization of std::pair](https://stackoverflow.com/questions/6885063/where-should-i-define-operator-for-my-specialization-of-stdpair) – user7860670 May 09 '18 at 16:15
"Isn't adding to namespace std UB?" - Usually, yes. But the standard explicitly allows adding template specializations to namespace std (and, as far as I know, that's the only thing you are allowed to add). – Jesper Juhl May 09 '18 at 16:24

R Sahu · Answer 2 · 2018-05-09T16:49:50.357

My ADL understanding is that it will look into the current namespace (that is AppNamespace::InnerNamespace) and since no << operator is found, it will look into the namespace of the arguments and as the CommonType is in global namespace I would expect that the << operator defined in the CommonTypes.h to be found.

The misunderstanding is that CommonType is a new type. It is not a new type. It is just an alias.

You can resolve the function lookup problem using various methods.

Define both the operator<< functions in the global namespace.

#include <string>
#include <sstream>
#include <iostream>
#include <vector>
#include <cstdint>

// Put everything from CommonTypes.h here to simplify things.
typedef std::vector<uint8_t> CommonType;

std::ostream& operator<<(std::ostream& os, CommonType const& bb)
{
   for (auto& el : bb)
   {
      os << el;
   }
   return os;
}

namespace AppNamespace
{
    typedef std::vector<std::string> OtherType;
}

std::ostream& operator << (std::ostream& os, const AppNamespace::OtherType& ot)
{
   for (auto& el : ot)
   {
      os << el;
   }
   return os;
}

namespace AppNamespace
{
   namespace InnerNamespace
   {
      void function()
      {
         CommonType bb;
         std::stringstream ss;
         ss << bb;
      }
   }
}


int main()
{
   AppNamespace::InnerNamespace::function();
   return 0;
}

Define both the operator<< functions in AppNamespace namespace.

#include <iostream>
#include <vector>
#include <cstdint>

// Put everything from CommonTypes.h here to simplify things.
typedef std::vector<uint8_t> CommonType;

namespace AppNamespace
{
   std::ostream& operator<<(std::ostream& os, CommonType const& bb)
   {
      for (auto& el : bb)
      {
         os << el;
      }
      return os;
   }

   typedef std::vector<std::string> OtherType;
   std::ostream& operator << (std::ostream& os, const OtherType& ot)
   {
      for (auto& el : ot)
      {
         os << el;
      }
      return os;
   }

   namespace InnerNamespace
   {
      void function()
      {
         CommonType bb;
         std::stringstream ss;
         ss << bb;
      }
   }
}


int main()
{
   AppNamespace::InnerNamespace::function();
   return 0;
}

Define std::ostream& operator<<(std::ostream& os, CommonType const& bb) in another namespace and explicitly bring that function into scope in AppNamespace.

#include <string>
#include <sstream>
#include <iostream>
#include <vector>
#include <cstdint>

// Put everything from CommonTypes.h here to simplify things.
typedef std::vector<uint8_t> CommonType;

namespace CommonNamespace
{
   std::ostream& operator<<(std::ostream& os, CommonType const& bb)
   {
      for (auto& el : bb)
      {
         os << el;
      }
      return os;
   }
}

namespace AppNamespace
{
   // Bring the operator<< functions in CommonNamespace into the scope of
   // this namespace.
   using CommonNamespace::operator<<;

   typedef std::vector<std::string> OtherType;
   std::ostream& operator << (std::ostream& os, const OtherType& ot)
   {
      for (auto& el : ot)
      {
         os << el;
      }
      return os;
   }

   namespace InnerNamespace
   {
      void function()
      {
         CommonType bb;
         std::stringstream ss;
         ss << bb;
      }
   }
}


int main()
{
   AppNamespace::InnerNamespace::function();
   return 0;
}

Thanks for the three solutions! – Iancu May 10 '18 at 09:39 — Iancu, May 10 '18 at 09:39

piarston · Answer 3 · 2018-05-09T16:17:07.697

0

If you don't want to move your operator in std namespace as recommended by VTT, you can specify that it lives in the global namespace:

(::operator <<)(ss, bb);

edited May 09 '18 at 16:17

answered May 09 '18 at 16:05

piarston

1,685
1
13
25

operator << argument-dependent lookup does not look in global namespace

3 Answers3