如何为一对中的第一个提供默认值？

Question

我使用的是pair类型：

typedef std::pair<int, std::string> Nomnom;

它的使用示例：

void DoIt(const Nomnom &toNom) { 
    ...
}
void DoItAgain(const Nomnom &toNomAgain) { 
    ...
}

在我的情况下，如果未指定，则为该对提供默认值是有意义的。也就是说，我希望能够做到这一点：

DoIt("Thisisit");
DoItAgain("Thisisit");

让它等同于这个：

DoIt(NomNom(0, "Thisisit"));
DoItAgain(NomNom(0, "Thisisit"));

我想在每次使用 Nomnom 时不定义两个变体。

除了为 Nomnom 定义一个类而不是 typedef，提供一个单参数构造函数，然后提供调用 std::pair 构造函数的零参数和双参数构造函数之外，有什么方法可以实现这一点？

Answer 1

您不能轻易地将自己的构造函数添加到 std::pair（从它继承并不是一个真正的选择）。

但是你可以提供一个小函数来构造它并相应地重载它：

Nomnom nomnom(const std::string& s) { return Nomnom(-1, s); }
Nomnom nomnom(int i) { return Nomnom(i, ""); }

您还可以重载 DoIt 和 DoItAgain 并转发一个通用实现。

void DoIt(const Nomnom& n) { /* ... */ }
void DoIt(int i) { DoIt(Nomnom(i, "")); }

Answer 2

原始问题

除了为 Nomnom 定义一个类，提供一个单参数构造函数，然后提供调用 std::pair 构造函数的零参数和双参数构造函数之外，还有什么方法可以实现这一点？

你可以有更多的构造函数重载

ClassNoms() : one(std::make_pair(-1,"") {}
ClassNoms(int id) : one(std::make_pair(id,"") {}
ClassNoms(const std::string& name) : one(std::make_pair(-1,name) {}
ClassNoms(int id, const std::string& name) : one(std::make_pair(id,name) {}

更新：

有没有什么办法可以实现这一点，除了为Nomnom 定义一个类而不是typedef，提供一个单参数构造函数，然后提供调用@987654324 的零参数和双参数构造函数@构造函数？

typedef std::pair<int, std::string> Nomnom;

您不能为 typedef'd NomNom 提供默认构造函数，因为 std::pair<> 没有提供默认构造函数。要实现这一点，您需要从std::pair<> 继承一个类NomNom，或者恕我直言，更好地为其提供一个包装器，并使用这个：

template<typename First,typename Second>
struct DefaultValuedPair {
     std::pair<First,Second> value;
     First& first;
     Second& second;
     DefaultValuedPair
        ( const First& first = First()
        , const Second& second = Second()
        ) 
     : value(std::make_pair(first,second))
     , first(value.first)
     , second(value.second) {}
     DefaultValuedPair(const std::pair<First,Second>& rhs) 
     : value(rhs)
     , first(value.first)
     , second(value.second) {}
     // Add more implicit type conversions for std::pair<First,Second>
     // as necessary ...
};

还有

typedef DefaultValuedPair<int, std::string> Nomnom;

你可以有一个像构造函数一样起作用的函数，但是它不能被命名和调用为NomNom（声明的）类型的纯等价物，这不会给出任何优于使用std::make_pair()。

建议的包装器解决方案可能会对重构使用NomNom 的现有代码的考虑产生巨大影响，并且应该与此类无缝协作。如前所述，只是替换/伪装std::make_pair 本身，没有任何意义恕我直言。

Answer 3

如果您使用的是 C++11，您可以只从与 using 配对的构造函数继承。我认为这是解决您的问题的最干净的解决方案。

您是否有不想从 std::pair 继承的原因（除了不想重新实现 std::pair 的构造函数）？

#include <utility>
#include <string>
#include <iostream>

/**
 * Nomnom is just a std::pair with a customized constructor.
 */
class Nomnom : public std::pair <int, std::string> {
  typedef std::pair<int, std::string> parent_type; // For convenience

  public:
  using parent_type::parent_type; // Inherit Pair's constructors
  Nomnom (std::string S) : parent_type(0, S) {} // And add our own
  Nomnom (char const * S) : parent_type(0, S) {} // Handle C strings...
};

/**
 * Show that we can just use Nomnom as a std::pair...
 */
template <class FIRST, class SECOND> 
std::ostream & operator<< (std::ostream & out, std::pair <FIRST, SECOND> const & print_me) {
  return out << print_me.first << ", " << print_me.second << '\n';
}

/**
 * Use this to test initizlization while passing to a method
 */
void foo (Nomnom const & print_me) {
  std::cout << print_me;
}

int main (void) {
  std::cout << Nomnom("Hello!");
  std::cout << Nomnom(5, "World!");
  foo ("Mouse!");

  return 0;
}