Как обеспечить значение по умолчанию для первой пары?

ОРИГИНАЛЬНЫЙ ВОПРОС

Есть ли способ сделать это, не ограничивая вместо этого определение класса для 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 определение класса для Nomnom вместо typedef, предоставляя конструктор с одним аргументом, а затем предоставляя конструкторы с нулевым аргументом и двумя аргументами, которые вызывают конструкторы std::pair?

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

Вы не можете предоставить конструктор по умолчанию для своего typedef 'd NomNom, потому что std::pair<> не предоставляет его. Для этого вам нужно либо наследовать класс NomNom из std::pair<>, либо IMHO лучше предоставить оболочку для него и использовать его:

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 сама по себе не имеет смысла ИМХО.

Если вы используете С++ 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 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;
}