如何使函数参数容器独立

Question

我正在编写一个实用函数，它将采用元素向量（可以是字符串、整数、双精度、字符）并连接成单个字符串并返回它。它看起来像这样：

template<typename T>
std::string convert2Str(std::vector<T> const& vec) 
{
   std::ostringstream sStream; 
   for (size_t k=0; k<vec.size(); ++k) {
      sStream << vec[k] << " "; 
   }
   return sStream.str(); 
}

我想让这个函数更通用：

• 首先使用迭代器而不是使用vector<T> 的索引。我试过这个 std::vector<T>::const_iterator it = vec.begin() 在循环之前和编译器给了我一个错误： : 错误: 预期 ; 在它之前 当我将上述定义更改为std::vector<std::string>::const_iterator it = vec.begin() 时，错误消失了。所以，看起来我没有遵循正确的语法，请告诉我它是什么
• 第二个是通过使第一个参数容器独立来使函数更通用。给定任何容器（vector、list、queue、deque 等）我想做和上面一样的事情。我尝试在 stackoverflow 中搜索，但没有找到满意的答案。

Answer 1

第 1 步，如您所说，使用迭代器：

template<typename T>
std::string convert2Str(std::vector<T> const& vec) 
{
   typedef std::vector<T> container;
   std::ostringstream sStream; 
   for (typename container::const_iterator it = vec.begin(); it != vec.end(); ++it) {
      sStream << *it << " "; 
   }
   return sStream.str(); 
}

第 2 步，将模板参数设为容器类型而不是元素类型（您可以通过 value_type 获取元素类型：

template<typename container>
std::string convert2Str(container const& vec)
{
   typedef container::value_type T; // if needed
   std::ostringstream sStream; 
   for (typename container::const_iterator it = vec.begin(); it != vec.end(); ++it) {
      sStream << *it << " "; 
   }
   return sStream.str(); 
}

在 C++0x 中，这变得更加简单（并且不需要 typename）：

template<typename container>
std::string convert2Str(container const& vec)
{
   using std::begin;
   using std::end;
   std::ostringstream sStream;
   for (auto it = begin(vec); it != end(vec); ++it) {
      typedef decltype(*it) T; // if needed
      sStream << *it << " "; 
   }
   return sStream.str(); 
}

除其他优点外，std::begin 和 std::end 适用于原始数组。

Answer 2

按照 STL 实践，我建议对输入参数使用两个迭代器，而不是一个容器（原因很明显，它只能使用容器的一部分，并且通常使用迭代器定义的任何序列）：

template<typename InputIterator>
std::string convert2Str(InputIterator first, InputIterator last)
{
    std::ostringstream sStream;
    for (InputIterator it = first; it != last; ++it) {
       sStream << *it << " ";
    }
    return sStream.str();
}

如果您需要包含对象的类型，请使用

typedef typename std::iterator_traits<InputIterator>::value_type T;

添加： 然后你可以使用如下函数：

std::vector<int> int_vec;
std::list<float> f_list;
std::deque<std::string> str_deq;

     // put something into the containers here

std::cout<< convert2Str(int_vec.begin(), int_vec.end()) <<std::endl;
std::cout<< convert2Str(f_list.begin(), f_list.end()) <<std::endl;
std::cout<< convert2Str(str_deq.begin(), str_deq.end()) <<std::endl;

请注意，您不能迭代 std::queue；但如果您真的需要它，该标准可以保证对自己动手的解决方案提供足够的支持。在此处查看更多信息：std::queue iteration。

Answer 3

如果您只对容器类型进行模板化，那是最简单的；值类型作为typedef 成员value_type 存储在所有标准、Boost 和Qt 容器中。 std::copy 和 ostream_iterator 允许您跳过冗长的迭代器声明。

template <typename Container>
std::string convert2Str(Container const &cont)
{
    std::ostringstream s;
    std::copy(cont.begin(), cont.end(),
              std::ostream_iterator<typename Container::value_type>(s, " "));
    return s.str();
}

typename 是避免歧义所必需的。当您省略此关键字时，最新版本的 GCC 会警告您。

Answer 4

使用这个。您需要 typename 部分来告诉编译器它应该在解析时考虑 T::const_iterator 类型，直到您实际调用传递一些具有 @ 的 T 的函数之前，它才能真正知道这是真的987654324@会员类型。

template<typename T>
std::string convert2Str(T const& cont) 
{
    std::ostringstream sStream; 
    for (typename T::const_iterator it = cont.begin(); it != cont.end(); ++it) {
        sStream << *it << " "; 
    }
    return sStream.str(); 
}

Answer 5

我认为这应该可行：

template<typename T>
std::string convert2Str(T const& container) 
{
   std::ostringstream sStream; 
   for (typename T::const_iterator i= container.begin(); i != container.end(); ++i) {
      sStream << *i << " "; 
   }
   return sStream.str(); 
}

演示：http://ideone.com/9pUVV