具有来自另一个命名空间的 typedef 的 ADL

Question

我有这样的事情：

#include <iostream>
namespace N
{
   typedef std::pair<int, double> MyPair;
   std::ostream& operator << (std::ostream& o, MyPair const & mypair)
   {
      ///
   }
}

int main()
{
    N::MyPair pr;
    std::cout << pr;
}

这自然行不通，因为 ADL 找不到 operator<< 因为 namespace N 与 MyPair 没有关联代码>（不幸的是）。据我所知，可能不会添加到命名空间 std，因此如果我选择在 std 中定义运算符 <<，那将是一种非法。那么...遇到这种情况该怎么办？我不想显式限定operator <<，也不希望编写using namespace N。那么问题来了：

1. 如何重构代码？
2. 为什么 ADL 不关联 typedef 的命名空间？严重的原因吗？例如在这种情况下，那就太好了。谢谢

Answer 1

1. 您可以在命名空间 N 中创建自己的类型，可能继承自 std::pair。您可以添加“using namespace N;”里面主要.前者更有可能有用。

2. 因为类型是在另一个命名空间中定义的，不能分两个定义。

示例：

namespace N { 
struct MyPair : std::pair<int, double> {
  MyPair(int first, double second) : std::pair<int, double>(first, second) {}
  // add defaults if desired: first=0, second=0.0
  // with defaults, you may want to make the ctor explicit or leave implicit

  // also, if desired and you don't use two defaults above:
  MyPair() : std::pair<int, double>(0, 0.0) {}

  // in 0x, you can "import" the base's ctors with a using declaration
};
}

如果用作 std::pair 并不重要，则可以删除继承并重命名成员。当然，在任何一种情况下，您都可以添加其他方法，但如果保留继承，则可以使用“重命名方法”：

int      & foo()       { return first; }
int const& foo() const { return first; }
double      & bar()       { return second; }
double const& bar() const { return second; }

Answer 2

我想不出 typedef 名称不应该参与 ADL 的原因。此外，它还定义了以下代码实现：

#include <algorithm>
#include <vector>

namespace my {
class A {};
void for_each();
} // my

int main()
{
    std::vector<my::A> v;
    for_each(v.begin(), v.end(), [...]);
} 

• 如果 std::vector::iterator 是位于 std 命名空间中的某个内容的 typedef：std::for_each 将被调用
• 如果 std::vector::iterator 是 my::A * 的 typedef：编译器应该抱怨 my:: for_each 不接受 3 个参数

Answer 3

您的选择是：

• 定义一个在其实现中使用 std::pair 的新类型，而不是使用 typedef
• 对输出函数使用不同的名称
• 在调用它时显式限定您想要的函数
• （也许） 在名称空间 std 中专门化该函数（我不确定 pair 是否算作 UDT）

这一切都源于 typedef 的主要优点和缺点：typedef 名称只是同义词。无论您将其放入哪个命名空间，typedef 名称都会引用关联的类型，无论该类型是在哪个命名空间中定义的。这与 typedef 不同，typedef 是可与关联类型相互转换的新类型。想象一下这种情况：

class C{};
typedef C id_t;
void f(C);
int f(id_t); // error: structurally equivalent to `int f(C);`

这是无效的，因为 int 和 id_t 不是不同的类型。这延伸到 ADL：

namespace A{
  class C{};
  void f(C);
  void g(C);
}

namespace B{
  typedef C id_t;
  int f(id_t); // structurally equivalent to `void f(C);`
}

B::id_t id; // completely equivalent to `A::C id;`
int n = f(id); // error: A::f doesn't return int

这里有一个问题要问你：你认为以下内容应该无法编译吗？如果没有，应该如何解决名称查找：

B::id_t id;
g(id);

Answer 4

我通过将相关符号拉入我想要使用它们的命名空间来解决这个问题：

#include <iostream>

namespace N
{
   typedef std::pair<int, double> MyPair;
   std::ostream& operator << (std::ostream& o, MyPair const & mypair)
   {
      ///
   }
}

using N::operator <<; // now it should compile

int main()
{
    N::MyPair pr;
    std::cout << pr;
}

Answer 5

您可以使用强类型定义：（

#include<boost/strong_typedef.hpp>    
#include<iostream>

namespace N
{
// typedef std::pair<int, double> MyPair;
   typedef std::pair<int, double> pair_int_double; 
   BOOST_STRONG_TYPEDEF(pair_int_double, MyPair);

   std::ostream& operator << (std::ostream& o, MyPair const & mypair)
   {
      return o;
   }
}

int main(){
    N::MyPair pr;
    std::cout << pr;
}

额外的类型定义仍然是必要的，以避免宏中出现额外的逗号。）

Answer 6

如果您想要输出特定的数据类型，您始终可以定义自己的类，而不是使用 std::pair。

struct myPair
{
  int first;
  double second;
};

Answer 7

允许向namespace::std添加模板函数的专门化，但是由于MyPair中使用的类型都不是用户定义的，我不确定这样的专业化是否合法。

namespace std {
     template<>
     ostream& operator<<(ostream& os, const MyPair& p) { }
}