运算符 << 依赖于参数的查找不在全局命名空间中查找

Question

在以下场景中，在 function() 内部，ss << bb 行出现错误：

binary '

我的 ADL 理解是它将查看当前命名空间（即 AppNamespace::InnerNamespace），由于没有找到 operator <<，它会查看参数的命名空间，因为 CommonType 在全局命名空间中我希望能够找到 CommonTypes.h 中定义的operator <<。 显然我的理解是错误的。谁能弄清楚这应该如何工作？

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;
}

Answer 1

这里的问题是 ADL 查找将在 std 命名空间中执行，而声明 CommonType 的命名空间不相关，因此为了使这项工作您需要将运算符

namespace std
{

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

}

Answer 2

我的 ADL 理解是它将查看当前命名空间（即 AppNamespace::InnerNamespace），由于没有找到 namespace 并且因为 CommonType 在全局命名空间我希望找到 CommonTypes.h 中定义的

误解是CommonType是一个新类型。它不是一种新类型。它只是一个别名。

您可以使用各种方法解决函数查找问题。

1. 在全局命名空间中定义两个 operator<< 函数。

   #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;
   }
   

2. 在 AppNamespace 命名空间中定义两个 operator<< 函数。

   #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;
   }
   

3. 在另一个命名空间中定义std::ostream& operator<<(std::ostream& os, CommonType const& bb)，并将该函数显式引入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;
   }
   

Answer 3

如果您不想按照 VTT 的建议将运算符移动到 std 命名空间中，您可以指定它位于全局命名空间中：

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