如何用参数包折叠实现类似PHP implode的concat函数？

我有一个concatenateBuffer函数（以下是简化版本），它的作用是将各类“字符串”（char*、std::string_view、std::string）追加到传入的buffer中：

#include <string>
#include <string_view>

template<typename... Args>
std::string_view concatenateBuffer(std::string &buffer, Args &&... args){
    static_assert((std::is_constructible_v<std::string_view, Args> && ...));

    buffer.clear();

    (buffer.append(std::forward<Args>(args)), ...);

    return buffer;
}

现在我想实现一个concat函数，行为类似PHP的implode——在传入的各个“字符串”参数之间插入分隔符,，示例如下：

concat(b, "a")           ===> "a"
concat(b, "a", "b")      ===> "a,b"
concat(b, "a", "b", "c") ===> "a,b,c"

请问能不能通过参数包折叠来实现这个需求？

完全可以用参数包折叠实现，核心思路是区分参数数量：单参数时直接追加；多参数时先追加第一个元素，再对剩余元素依次追加分隔符+元素。以下是两种实用实现方式：

方式一：拆分单/多参数模板（可读性最优） #

通过重载模板分别处理单参数和多参数场景，逻辑清晰且无额外开销：

#include <string>
#include <string_view>
#include <type_traits>

template<typename... Args>
std::string_view concatenateBuffer(std::string &buffer, Args &&... args){
    static_assert((std::is_constructible_v<std::string_view, Args> && ...));
    buffer.clear();
    (buffer.append(std::forward<Args>(args)), ...);
    return buffer;
}

// 单参数版本：直接调用concatenateBuffer追加元素
template<typename T>
std::string_view concat(std::string &buffer, T &&t) {
    return concatenateBuffer(buffer, std::forward<T>(t));
}

// 多参数版本：先追加首元素，再用折叠表达式依次追加分隔符+后续元素
template<typename First, typename... Rest>
std::string_view concat(std::string &buffer, First &&first, Rest &&... rest) {
    buffer.clear();
    buffer.append(std::forward<First>(first));
    (buffer.append(",").append(std::forward<Rest>(rest)), ...);
    return buffer;
}

#include <iostream>

int main(){
    std::string b;

    std::cout << concat(b, "a") << '\n';          // 输出：a
    std::cout << concat(b, "a", "b") << '\n';     // 输出：a,b
    std::cout << concat(b, "a", "b", "c") << '\n';// 输出：a,b,c
}

方式二：单模板函数内实现（紧凑写法） #

如果想把逻辑塞进单个模板函数，可以借助std::initializer_list先获取首元素，再用折叠表达式处理剩余元素：

#include <string>
#include <string_view>
#include <type_traits>
#include <initializer_list>

template<typename... Args>
std::string_view concatenateBuffer(std::string &buffer, Args &&... args){
    static_assert((std::is_constructible_v<std::string_view, Args> && ...));
    buffer.clear();
    (buffer.append(std::forward<Args>(args)), ...);
    return buffer;
}

template<typename... Args>
std::enable_if_t<sizeof...(Args) > 0, std::string_view>
concat(std::string &buffer, Args &&... args) {
    static_assert((std::is_constructible_v<std::string_view, Args> && ...));
    buffer.clear();
    
    // 用initializer_list获取首元素
    auto args_list = {std::forward<Args>(args)...};
    buffer.append(*args_list.begin());
    // 折叠追加分隔符+剩余元素
    ((buffer.append(",").append(std::forward<Args>(args))), ...);
    
    return buffer;
}

注意事项 #

• 原代码中concat的参数std::string s是传值调用，每次都会复制字符串，建议改成传引用（如上述实现中的std::string &buffer），避免不必要的性能损耗。
• 两种实现都严格遵循需求：单参数时无分隔符，多参数时仅在元素之间插入分隔符。

内容的提问来源于stack exchange，提问作者Nick