如何将字符串向量内爆成字符串（优雅的方式）

Question

我正在寻找将字符串向量内爆为字符串的最优雅方法。以下是我现在使用的解决方案：

static std::string& implode(const std::vector<std::string>& elems, char delim, std::string& s)
{
    for (std::vector<std::string>::const_iterator ii = elems.begin(); ii != elems.end(); ++ii)
    {
        s += (*ii);
        if ( ii + 1 != elems.end() ) {
            s += delim;
        }
    }

    return s;
}

static std::string implode(const std::vector<std::string>& elems, char delim)
{
    std::string s;
    return implode(elems, delim, s);
}

还有其他人吗？

Answer 1

你应该使用std::ostringstream而不是std::string来构建输出（然后你可以在最后调用它的str()方法来得到一个字符串，所以你的接口不需要改变，只有临时的s） .

从那里，您可以改为使用std::ostream_iterator，如下所示：

copy(elems.begin(), elems.end(), ostream_iterator<string>(s, delim)); 

但这有两个问题：

1. delim 现在需要是 const char*，而不是单个 char。没什么大不了的。
2. std::ostream_iterator 在每个元素之后写入分隔符，包括最后一个元素。所以你要么需要在最后删除最后一个，要么编写你自己的迭代器版本，它没有这种烦恼。如果你有很多代码需要这样的东西，那么后者是值得的；否则最好避免整个混乱（即使用ostringstream而不是ostream_iterator）。

Answer 2

std::vector<std::string> strings;

const char* const delim = ", ";

std::ostringstream imploded;
std::copy(strings.begin(), strings.end(),
           std::ostream_iterator<std::string>(imploded, delim));

（包括<string>、<vector>、<sstream> 和<iterator>）

If you want to have a clean end (no trailing delimiter) have a look here

Answer 3

略长的解决方案，但不使用std::ostringstream，并且不需要破解来删除最后一个分隔符。

http://www.ideone.com/hW1M9

还有代码：

struct appender
{
  appender(char d, std::string& sd, int ic) : delim(d), dest(sd), count(ic)
  {
    dest.reserve(2048);
  }

  void operator()(std::string const& copy)
  {
    dest.append(copy);
    if (--count)
      dest.append(1, delim);
  }

  char delim;
  mutable std::string& dest;
  mutable int count;
};

void implode(const std::vector<std::string>& elems, char delim, std::string& s)
{
  std::for_each(elems.begin(), elems.end(), appender(delim, s, elems.size()));
}

Answer 4

使用std::accumulate的版本：

#include <numeric>
#include <iostream>
#include <string>

struct infix {
  std::string sep;
  infix(const std::string& sep) : sep(sep) {}
  std::string operator()(const std::string& lhs, const std::string& rhs) {
    std::string rz(lhs);
    if(!lhs.empty() && !rhs.empty())
      rz += sep;
    rz += rhs;
    return rz;
  }
};

int main() {
  std::string a[] = { "Hello", "World", "is", "a", "program" };
  std::string sum = std::accumulate(a, a+5, std::string(), infix(", "));
  std::cout << sum << "\n";
}

Answer 5

使用boost::algorithm::join(..):

#include <boost/algorithm/string/join.hpp>
...
std::string joinedString = boost::algorithm::join(elems, delim);

另见this question。

Answer 6

因为我喜欢单线（它们对于各种奇怪的东西都非常有用，正如您将在最后看到的那样），这里有一个使用 std::accumulate 和 C++11 lambda 的解决方案：

std::accumulate(alist.begin(), alist.end(), std::string(), 
    [](const std::string& a, const std::string& b) -> std::string { 
        return a + (a.length() > 0 ? "," : "") + b; 
    } )

我发现这种语法对流操作符很有用，我不想让各种奇怪的逻辑超出流操作的范围，只是为了做一个简单的字符串连接。例如，考虑使用流运算符（使用 std;）格式化字符串的方法的返回语句：

return (dynamic_cast<ostringstream&>(ostringstream()
    << "List content: " << endl
    << std::accumulate(alist.begin(), alist.end(), std::string(), 
        [](const std::string& a, const std::string& b) -> std::string { 
            return a + (a.length() > 0 ? "," : "") + b; 
        } ) << endl
    << "Maybe some more stuff" << endl
    )).str();

更新：

正如@plexando 在 cmets 中指出的那样，当数组以空字符串开头时，上述代码会出现异常行为，因为“第一次运行”的检查缺少以前没有额外字符的运行，而且 - 在所有运行时检查“首次运行”是很奇怪的（即代码未优化）。

如果我们知道列表至少有一个元素，那么这两个问题的解决方案就很容易了。 OTOH，如果我们知道列表没有至少有一个元素，那么我们可以进一步缩短运行时间。

我认为生成的代码不是那么漂亮，所以我在这里将其添加为正确的解决方案，但我认为上面的讨论仍然有优点：

alist.empty() ? "" : /* leave early if there are no items in the list */
  std::accumulate( /* otherwise, accumulate */
    ++alist.begin(), alist.end(), /* the range 2nd to after-last */
    *alist.begin(), /* and start accumulating with the first item */
    [](auto& a, auto& b) { return a + "," + b; });

注意事项：

• 对于支持直接访问第一个元素的容器，最好将它用于第三个参数，因此alist[0] 用于向量。
• 根据 cmets 和聊天中的讨论，lambda 仍然会进行一些复制。这可以通过使用这个（不太漂亮的）lambda 来最小化：[](auto&& a, auto&& b) -> auto& { a += ','; a += b; return a; })（在 GCC 10 上）将性能提高了 10 倍以上。感谢@Deduplicator 的建议。我仍在试图弄清楚这里发生了什么。

Answer 7

string join(const vector<string>& vec, const char* delim)
{
    stringstream res;
    copy(vec.begin(), vec.end(), ostream_iterator<string>(res, delim));
    return res.str();
}

Answer 8

这是另一个没有在最后一个元素后添加分隔符的：

std::string concat_strings(const std::vector<std::string> &elements,
                           const std::string &separator)
{       
    if (!elements.empty())
    {
        std::stringstream ss;
        auto it = elements.cbegin();
        while (true)
        {
            ss << *it++;
            if (it != elements.cend())
                ss << separator;
            else
                return ss.str();
        }       
    }
    return "";

Answer 9

这是我用的，简单灵活

string joinList(vector<string> arr, string delimiter)
{
    if (arr.empty()) return "";

    string str;
    for (auto i : arr)
        str += i + delimiter;
    str = str.substr(0, str.size() - delimiter.size());
    return str;
}

使用：

string a = joinList({ "a", "bbb", "c" }, "!@#");

输出：

a!@#bbb!@#c

Answer 10

尤其是对于较大的集合，您希望避免检查是否仍在添加第一个元素以确保没有尾随分隔符...

所以对于空的或者单元素的列表，根本就没有迭代。

空范围很简单：返回 ""。

单元素或多元素都可以完美处理accumulate：

auto join = [](const auto &&range, const auto separator) {
    if (range.empty()) return std::string();

    return std::accumulate(
         next(begin(range)), // there is at least 1 element, so OK.
         end(range),

         range[0], // the initial value

         [&separator](auto result, const auto &value) {
             return result + separator + value;
         });
};

运行示例（需要 C++14）：http://cpp.sh/8uspd

Answer 11

那么简单愚蠢的解决方案呢？

std::string String::join(const std::vector<std::string> &lst, const std::string &delim)
{
    std::string ret;
    for(const auto &s : lst) {
        if(!ret.empty())
            ret += delim;
        ret += s;
    }
    return ret;
}

Answer 12

将这个answer 的一部分用于另一个问题会给你一个加入这个，基于没有尾随逗号的分隔符，

用法：

std::vector<std::string> input_str = std::vector<std::string>({"a", "b", "c"});
std::string result = string_join(input_str, ",");
printf("%s", result.c_str());
/// a,b,c

代码：

std::string string_join(const std::vector<std::string>& elements, const char* const separator)
{
    switch (elements.size())
    {
        case 0:
            return "";
        case 1:
            return elements[0];
        default:
            std::ostringstream os;
            std::copy(elements.begin(), elements.end() - 1, std::ostream_iterator<std::string>(os, separator));
            os << *elements.rbegin();
            return os.str();
    }
}

Answer 13

我喜欢使用这种单行累加（没有尾随分隔符）：

std::accumulate(
    std::next(elems.begin()), 
    elems.end(), 
    elems[0], 
    [](std::string a, std::string b) {
        return a + delimiter + b;
    }
);

Answer 14

使用三元运算符?: 的可能解决方案。

std::string join(const std::vector<std::string> & v, const std::string & delimiter = ", ") {
    std::string result;

    for (size_t i = 0; i < v.size(); ++i) {
        result += (i ? delimiter : "") + v[i]; 
    }

    return result;
}

join({"2", "4", "5"}) 会给你2, 4, 5。

Answer 15

使用 fmt 你可以做到。

#include <fmt/format.h>
auto s = fmt::format("{}",fmt::join(elems,delim)); 

但我不知道 join 是否会变成 std​​::format。

Answer 16

这可以使用 boost 解决

#include <boost/range/adaptor/filtered.hpp>
#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/algorithm.hpp>

std::vector<std::string> win {"Stack", "", "Overflow"};
const std::string Delimitor{","};

const std::string combined_string = 
                  boost::algorithm::join(win |
                         boost::adaptors::filtered([](const auto &x) {
                                                      return x.size() != 0;
                                                      }), Delimitor);

Output:

combined_string: "Stack,Overflow"

Answer 17

另一个简单而好的解决方案是使用ranges v3。当前版本是 C++14 或更高版本，但也有 C++11 或更高版本的旧版本。不幸的是，C++20 范围没有intersperse 函数。

这种方法的好处是：

• 优雅
• 轻松处理空字符串
• 处理列表的最后一个元素
• 效率。因为范围是惰性求值的。
• 小而实用的库

功能分解(Reference)：

• accumulate = 类似于std::accumulate，但参数是范围和初始值。还有一个可选的第三个参数是操作符函数。
• filter = 与std::filter 一样，过滤不符合谓词的元素。
• intersperse = 关键功能！在范围输入元素之间散布分隔符。

#include <iostream>
#include <string>
#include <vector>
#include <range/v3/numeric/accumulate.hpp>
#include <range/v3/view/filter.hpp>
#include <range/v3/view/intersperse.hpp>

int main()
{
    using namespace ranges;
    // Can be any std container
    std::vector<std::string> a{ "Hello", "", "World", "is", "", "a", "program" };
    
    std::string delimiter{", "};
    std::string finalString = 
        accumulate(a | views::filter([](std::string s){return !s.empty();})
                     | views::intersperse(delimiter)
                  , std::string());
    std::cout << finalString << std::endl; // Hello, World, is, a, program
}

Answer 18

虽然我通常会根据最佳答案推荐使用 Boost，但我承认在某些项目中这是不希望的。

使用 std::ostream_iterator 建议的 STL 解决方案将无法按预期工作 - 它会在末尾附加一个分隔符。

现在有一种方法可以用现代 C++ 做到这一点，但是，使用 https://en.cppreference.com/w/cpp/experimental/ostream_joiner：

std::ostringstream outstream;
std::copy(strings.begin(),
          strings.end(),
          std::experimental::make_ostream_joiner(outstream, delimiter.c_str()));
return outstream.str();