структурированные аргументы как вариационный шаблон - PullRequest
Новая
       20

структурированные аргументы как вариационный шаблон

1 голос
/ 13 марта 2019

У меня есть метод, которому нужны два параметра: псевдоним (строка) и объект (любого типа).

Теперь я хотел бы иметь (шаблонный) метод, принимающий n из этих пар; Синтаксис должен выглядеть следующим образом: 

append (
  { "first", int { 3 } },
  { "second", double { 2. } },
  { "third", std::string { "test" } }
);

Что я сейчас делаю, так это: 

void append() {}

template<typename Type>
void append(std::string str, Type obj)
{
  std::cout << "str: " << str << " type: " << obj << "\n";
}

template<typename Type, typename... Args>
void append(std::string str, Type t, Args... args)
{
  append(str, t);
  append(args...);
}

int main()
{
 append("first", 1, "second", 2., "third, "test");
}

Что позволяет написать что-то вроде этого 

append (
  "first", int { 3 },
  "second", double { 2. },
  "third", std::string { "test" }
);

Но, на мой взгляд, это сделало бы код более читабельным, если бы я мог использовать фигурные скобки, как в моем примере выше.

Я пытался использовать шаблонную std :: pair, но все, что я получаю, это ошибки компилятора: 

main.cpp:9:6: note: template<class Type> void 

append(std::initializer_list<std::pair<std::basic_string<char>, Type> >)
 void append(std::initializer_list<std::pair<std::string, Type>> pair)
      ^
main.cpp:9:6: note:   template argument deduction/substitution failed:
main.cpp:23:22: note:   couldn't deduce template parameter ‘Type’
  append({"first", 1});

У кого-нибудь есть идея?

1 Ответ

2 голосов
/ 13 марта 2019

Вы, вероятно, можете использовать boost :: assign или что-то подобное: 

 class t_Append final
 {
     private: ::std::ostream & m_where;

     public: explicit
     t_Append
     (
         ::std::ostream & where
     ) noexcept
     :   m_where{where}
     {
         return;
     }

     public: explicit
     t_Append
     (
          t_Append && other
     ) noexcept
     :    m_where{other.m_where}
     {
          return;
     }

     public: template
     <
         typename x_Object
     > auto
     operator ()
     (
          char const * const psz_str
     ,    x_Object const & object
     ) &&
     {
          m_where << "str: " << psz_str << " type: " << object << "\n";
          return t_Append{::std::move(*this)};
     }
 };

 inline auto
 Append(::std::ostream & where)
 {
     return t_Append{where};
 }

использование: 

 Append(::std::cout)
     ("first", int{3})
     ("second", double{2.0})
     ("third", ::std::string{"test"});
...