如何避免在 std::pair 中“隐式”调用单参数构造函数

Question

最初的问题是如何以安全的方式使用std::map<std::wstring, std::wstring> >，因为相同类型的键和值非常容易出错。所以我决定为这个值创建一个简单的包装器：

    struct ComponentName
    {
      std::wstring name;

      // I want to prohibit any implicit string-ComponentName conversions!!!
      explicit ComponentName(const std::wstring& _name) : name(_name)
      {
      }

      bool operator<(const ComponentName& item_to_compare) const
      {
        return name < item_to_compare.name;
      }
    };

    typedef std::map<std::wstring, ComponentName> component_names_map;

但是下面的代码运行良好！

component_names_map component_names;
// Are you sure that ComponentName's constructor cannot be called implicitly? ;)
component_names_map::value_type a_pair = std::make_pair(L"Foo", L"Bar");

之所以有效，是因为 std::pair<std::wstring, ComponentName> 复制构造函数显式使用 ComponentName 的字符串构造函数来分配 std::pair<std::wstring, std::wstring> 实例。这是绝对合法的操作。但是，它看起来是对 ComponentName 构造函数的“隐式”调用。

所以我知道问题的原因，但是如何避免这种“隐式”wstring-ComponentName 转换？ 最简单的方法是不声明字符串构造函数，但是这样会使得 ComponentName 初始化不方便。

Answer 1

我认为您可以通过为您的类型添加 std::pair 的部分专业化来合法地做到这一点：

namespace std {
    template <typename T>
    struct pair<T,ComponentName> {
       typedef T first_type;
       typedef ComponentName second_type;

       T first;
       ComponentName second;
       // The rest of the pair members:
       // ....
       // Any trick you like to make it fail with assignment/construction from 
       // pair<std::wstring, std::wstring>
    };
}

理由：

第 17.6.4.2.1 节规定了 std 命名空间中特化的基本规则：

"程序可以为任何标准库添加模板特化 仅当声明依赖于 用户定义类型和特化符合标准库 原始模板的要求，并且没有明确说明 禁止”

如果您在 § 20.3 的范围内填写了课程的其余部分，我看不出有任何明确的禁令可以排除这种特殊情况。

---

替代的，可能是合法的方法：

特化std::is_constructible<ComponentName, std::wstring> 使得value 为假。这被列为不同类型的std::pairs 的赋值运算符和复制构造函数的要求。通过快速扫描，我也看不到任何禁令，但我找不到任何说明需要实现来检查要求。

Answer 2

问题（在 C++03 中）是大多数标准库实现并不真正符合标准。特别是，该标准规定，当 std::pair<T,U> 从不同的 std::pair<V,W> 构造时，成员是通过隐式转换构造的。问题是实际上很难（如果可能的话）在模板化 pair 构造函数的实现中限制这种转换，因此当前的实现对参数执行显式转换：

template <typename T, typename U>
struct pair {
    // ...
    template <typename V, typename W>
    pair( pair<V,W> const & p ) : first( p.first ), second( p.second ) {} 
};

我实际上写了一篇关于这个特殊案例here 的博客文章，为此我尝试提供适当的转换构造函数here，但该解决方案不符合标准（即它的签名不同于标准要求的）。

注意：在 C++11（§20.3.2p12-14）中，这种隐式转换也是被禁止的（来自 FDIS）：

template<class U, class V> pair(pair<U, V>&& p);

要求：is_constructible::value 为真，is_constructible::value 为真。

效果：构造函数首先用 std::forward(p.first) 初始化，其次用 std::forward(p.second) 初始化。

备注：除非 U 可隐式转换为 first_type 且 V 可隐式转换为 second_type，否则此构造函数不应参与重载决议。

在 p9-11 中存在与 template<class U, class V> pair(const pair<U, V>& p); 等效的等效限制（如果类型不是可移动的）

Answer 3

简单：

enum FromString { fromString };

ComponentName( FromString, std::wstring const& aName)
    : name( aName )
{}