std ::向带自定义分隔符的字符串向量

Question

我想用自定义分隔符将vector的内容复制到一个长string。到目前为止，我已经试过：

// .h 
string getLabeledPointsString(const string delimiter=","); 
// .cpp 
string Gesture::getLabeledPointsString(const string delimiter) { 
    vector<int> x = getLabeledPoints(); 
    stringstream s; 
    copy(x.begin(),x.end(), ostream_iterator<int>(s,delimiter)); 
    return s.str(); 
} 

，但我得到

no matching function for call to ‘std::ostream_iterator<int, char, std::char_traits<char> >::ostream_iterator(std::stringstream&, const std::string&)’ 

我试着charT*但我得到

error iso c++ forbids declaration of charT with no type 

然后我试图使用char和ostream_iterator<int>(s,&delimiter) 但我在字符串中出现奇怪的字符。

任何人都可以帮助我理解编译器在这里期待什么吗？

Answer 1

Use delimiter.c_str() as the delimiter：

copy(x.begin(),x.end(), ostream_iterator<int>(s,delimiter.c_str())); 

这样的话，你会得到一个const char*指向字符串，这是ostream_operator从std::string期待。

Answer 2

std::string Gesture::getLabeledPointsString(const std::string delimiter) { 
    return boost::join(getLabeledPoints(), delimiter); 
} 

我并不信服在这一点上introducting getLabeledPointsString）

Answer 3

另一种方式来做到这一点：

#include <iostream> 
#include <string> 
#include <vector> 
#include <sstream> 
using namespace std; 

template <typename T> 
string join(const T& v, const string& delim) { 
    ostringstream s; 
    for (const auto& i : v) { 
     if (&i != &v[0]) { 
      s << delim; 
     } 
     s << i; 
    } 
    return s.str(); 
} 

int main() { 
    cout << join(vector<int>({1, 2, 3, 4, 5}), ",") << endl; 
} 

（C++ 11系列为基础的循环和“汽车'虽然）

Answer 4

C++ 11：

vector<string> x = {"1", "2", "3"}; 
string s = std::accumulate(std::begin(x), std::end(x), string(), 
           [](string &ss, string &s) 
           { 
            return ss.empty() ? s : ss + "," + s; 
           }); 

Answer 5

更快变体：

vector<string> x = {"1", "2", "3"}; 
string res; 
res.reserve(16); 

std::accumulate(std::begin(x), std::end(x), 0, 
       [&res](int &, string &s) 
       { 
        if (!res.empty()) 
        { 
         res.append(","); 
        } 
        res.append(s); 
        return 0; 
       }); 

它不创建临时字符串，但只是针对整个字符串结果分配内存一次并追加各ELEM到的& RES

Answer 6

int array[ 6 ] = { 1, 2, 3, 4, 5, 6 }; 
std::vector<int> a(array, array + 6); 
stringstream dataString; 
ostream_iterator<int> output_iterator(dataString, ";"); // here ";" is delimiter 
std::copy(a.begin(), a.end(), output_iterator); 
cout<<dataString.str()<<endl; 

输出= 1的端; 2; 3; 4; 5; 6;

Answer 7

这是上面提供的两个答案的扩展，因为运行时间性能似乎是评论中的一个主题。我会将它添加为注释，但我还没有该特权。

我使用Visual Studio 2015年测试2个实现了运行时性能：

使用字符串流：

std::stringstream result; 
auto it = vec.begin(); 
result << (unsigned short)*it++; 
for (; it != vec.end(); it++) { 
    result << delimiter; 
    result << (unsigned short)*it; 
} 
return result.str(); 

使用积累：

std::string result = std::accumulate(std::next(vec.begin()), vec.end(), 
    std::to_string(vec[0]), 
    [&delimiter](std::string& a, uint8_t b) { 
    return a + delimiter+ std::to_string(b); 
}); 
return result; 

发布版本运行时性能很接近有一些微妙之处。

累积实施速度稍微快一点（20-50ms，在1000次迭代中整个运行时间（〜180ms）的约10-30％）。但是，accumulate实现只有在lambda函数的a参数通过引用传递时才会更快。按值传递a参数导致类似的运行时差异有利于stringstream实现。当结果字符串直接返回而不是分配给立即返回的局部变量时，accumulate实现也得到了改进。 YMMV与其他C++编译器。

调试版本使用accumulate慢了5-10倍，所以我认为上面几个注释中提到的额外字符串创建由优化器解决。

我正在看一个具体的实施，使用uint8_t值的vector。完整的测试代码如下：

#include <vector> 
#include <iostream> 
#include <sstream> 
#include <numeric> 
#include <chrono> 

using namespace std; 
typedef vector<uint8_t> uint8_vec_t; 

string concat_stream(const uint8_vec_t& vec, string& delim = string(" ")); 
string concat_accumulate(const uint8_vec_t& vec, string& delim = string(" ")); 

string concat_stream(const uint8_vec_t& vec, string& delimiter) 
{ 
    stringstream result; 

    auto it = vec.begin(); 
    result << (unsigned short)*it++; 
    for (; it != vec.end(); it++) { 
     result << delimiter; 
     result << (unsigned short)*it; 
    } 
    return result.str(); 
} 

string concat_accumulate(const uint8_vec_t& vec, string& delimiter) 
{ 
    return accumulate(next(vec.begin()), vec.end(), 
     to_string(vec[0]), 
     [&delimiter](string& a, uint8_t b) { 
     return a + delimiter + to_string(b); 
    }); 
} 

int main() 
{ 
    const int elements(256); 
    const int iterations(1000); 

    uint8_vec_t test(elements); 
    iota(test.begin(), test.end(), 0); 

    int i; 
    auto stream_start = chrono::steady_clock::now(); 
    string join_with_stream; 
    for (i = 0; i < iterations; ++i) { 
     join_with_stream = concat_stream(test); 
    } 
    auto stream_end = chrono::steady_clock::now(); 

    auto acc_start = chrono::steady_clock::now(); 
    string join_with_acc; 
    for (i = 0; i < iterations; ++i) { 
     join_with_acc = concat_accumulate(test); 
    } 
    auto acc_end = chrono::steady_clock::now(); 

    cout << "Stream Results:" << endl; 
    cout << " elements: " << elements << endl; 
    cout << " iterations: " << iterations << endl; 
    cout << " runtime: " << chrono::duration<double, milli>(stream_end - stream_start).count() << " ms" << endl; 
    cout << " result: " << join_with_stream << endl; 

    cout << "Accumulate Results:" << endl; 
    cout << " elements: " << elements << endl; 
    cout << " iterations: " << iterations << endl; 
    cout << " runtime: " << chrono::duration<double, milli>(acc_end - acc_start).count() << " ms" << endl; 
    cout << " result:" << join_with_acc << endl; 

    return 0; 
} 

Answer 8

string join(const vector<string> & v, const string & delimiter = ",") { 
    string out; 
    if (auto i = v.begin(), e = v.end(); i != e) { 
     out += *i++; 
     for (; i != e; ++i) out.append(delimiter).append(*i); 
    } 
    return out; 
} 

的几点：

• 你并不需要一个额外的条件，以避免额外的尾随分隔符
• 确保你不死机当向量为空时
• 不会制作一堆临时对象（例如，不要这样做：x = x + d + y）