Как реализовать специализированную специализацию?

Question

Теперь функция «JoinStrings», которую я использую, может присоединяться только к типу данных std :: string. Мне нужно теперь присоединиться к целому числу. Поэтому я надеюсь реорганизовать его. Но я потерпел неудачу. Я рад слышать «вы не можете так поступать», потому что я действительно не знаю, разумно ли использовать эти коды таким образом или нет.

вызывающую часть:

int main(int argc, char* argv[]) { 
     vector<int> integers; 
     string str = JoinStrings(integers); 
     cout << str << endl; 
} 

---

Часть I не удалось осуществить:

#include <string> 

template <class ConstForwardIterator> 
void JoinStrings(const ConstForwardIterator& begin, 
       const ConstForwardIterator& end, 
       const std::string& delimiter, 
       std::string* output) { 
    output->clear(); 
    for (ConstForwardIterator iter = begin; iter != end; ++iter) { 
    if (iter != begin) { 
     output->append(delimiter); 
    } 
    output->append(*iter); 
    } 
} 

// What data type should be declared for IntegerConstForwardIterator? 
template<> 
void JoinStrings(const IntegerConstForwardIterator& begin, 
       const IntegerConstForwardIterator& end, 
       const std::string& delimiter, 
       std::string* output) { 
    output->clear(); 
    for (IntegerConstForwardIterator iter = begin; iter != end; ++iter) { 
    if (iter != begin) { 
     output->append(delimiter); 
    } 
    output->append(std::to_string(*iter)); 
    } 
} 

template <class ConstForwardIterator> 
std::string JoinStrings(const ConstForwardIterator& begin, 
         const ConstForwardIterator& end, 
         const std::string& delimiter) { 
    std::string output; 
    JoinStrings(begin, end, delimiter, &output); 
    return output; 
} 

template <class Container> 
std::string JoinStrings(const Container& container, 
         const std::string& delimiter = " ") { 
    return JoinStrings(container.begin(), container.end(), delimiter); 
} 

Answer 1

Можно изменить код, чтобы достичь того, чего вы хотите. Я интерпретирую этот вопрос как упражнение по шаблонной специализации. (Для рекомендуемой альтернативы, следовать комментарий jogojapan в)

Предисловие: Я ожидал, что это сработает, но (хотя он компилирует) это не потому, что общая версия еще лучше матч:

template<template <class> class Cont > 
void JoinStrings(const typename Cont<int>::const_iterator& begin, 
       const typename Cont<int>::const_iterator& end, 
       const std::string& delimiter, 
       std::string* output) { 
    std::clog << "specialized called" << std::endl; 
    .... 
} 

Итак, мне пришлось прибегнуть к добрым старым enable_if (я использую C++ 11 для краткости здесь, с некоторыми усилиями можно сделать в C++ 98). С кодом main вызывается специализированная версия.

Решение

#include<type_traits> 
.... 
template <class ConstForwardIterator, 
    class = typename std::enable_if<not std::is_same<typename std::decay<decltype(*std::declval<ConstForwardIterator>())>::type, int>::value>::type 
> 
void JoinStrings(const ConstForwardIterator& begin, 
       const ConstForwardIterator& end, 
       const std::string& delimiter, 
       std::string* output) { 
    std::clog << "generic called" << std::endl; 
    std::clog << std::trace() << std::endl; 
} 

template <class ConstForwardIterator, 
    class = typename std::enable_if<std::is_same<typename std::decay<decltype(*std::declval<ConstForwardIterator>())>::type, int>::value>::type, 
    class Tag = void 
> 
void JoinStrings(const ConstForwardIterator& begin, 
       const ConstForwardIterator& end, 
       const std::string& delimiter, 
       std::string* output) { 
    std::clog << "special called" << std::endl; 
    .... 
} 

Более классическое решение является использование "Tag диспетчерскую" http://www.boost.org/community/generic_programming.html#tag_dispatching, но requieres изменить больше кода, как ваш Container-версии JoinString.

Ограниченного решение: В случае, если вы ожидаете код для работы только с std::vector Решения намного проще:

template <> 
void JoinStrings(const std::vector<int>::const_iterator& begin, 
       const std::vector<int>::const_iterator& end, 
       const std::string& delimiter, 
       std::string* output) 

Answer 2

Является ли это то, что вы хотите? Как сказал @jogojapan, использование std :: ostringstream - лучший выбор.

#include <vector> 
#include <string> 
#include <iostream> 
#include <sstream> 

template <class ConstForwardIterator> 
std::string JoinStrings(const ConstForwardIterator& begin, 
     const ConstForwardIterator& end, 
     const std::string& delimiter) { 
    std::ostringstream oss; 
    for (ConstForwardIterator iter = begin; iter != end; ++iter) { 
     if (iter != begin) { 
      oss << delimiter; 
     } 
     oss << *iter; 
    } 
    return oss.str(); 
} 

template <class Container> 
std::string JoinStrings(const Container &container, 
     const std::string& delimiter = " ") { 
    return JoinStrings(container.begin(), 
      container.end(), delimiter); 
} 

int main(int argc, char *argv[]) { 
    std::vector<int> integers; 
    integers.push_back(1); 
    integers.push_back(2); 
    integers.push_back(3); 
    std::string str = JoinStrings(integers); 
    std::cout << str << std::endl; 

    std::vector<std::string> strings; 
    strings.push_back("MOU"); 
    strings.push_back("BI"); 
    str = JoinStrings(strings); 
    std::cout << str << std::endl; 
    return 0; 
}