如何仅向C++函数传递选定参数？是否需使用可变参数模板？

我有一个结构体X，希望依据传入的参数条件填充其所有字段。需要区分传递给函数的参数，根据传入的参数创建并返回X对象。请问在C++中是否应该使用可变参数模板？以下是我的伪代码：

#include <iostream>

using namespace std;

struct X
{
    string a;
    string b;
    string c;
};

X generateTransaction(const string& e, const string& f, const string& g)
{
    X one;
    if (!e.empty())
        one.a = e;
    if (!f.empty())
        one.b = f;
    if (!g.empty())
        one.c = g;
    return one;
}

int main()
{
    generateTransaction(e = "first");
    generateTransaction(e = "abc", f = "second");
    generateTransaction(g = "third");
    generateTransaction(e = "test", g = "third");
    generateTransaction("m", "n", "o");
    return 0;
}

首先得明确：你伪代码里的调用方式（比如generateTransaction(e = "first")）在标准C++里是不合法的——这本质是把赋值表达式的结果当参数传，而且原函数要求三个参数，只传一个会直接编译报错。要实现命名参数式的灵活传参，可变参数模板是可行方案之一，但也有其他更直观的替代方案，下面逐一说明：

方案一：用可变参数模板实现命名参数 #

可以给每个字段定义对应的"赋值标签"，再通过可变参数模板遍历参数，给结构体对应字段赋值：

#include <iostream>
#include <string>
#include <utility> // 用于std::forward

using namespace std;

struct X
{
    string a;
    string b;
    string c;
};

// 定义字段标签类型
struct ATag {};
struct BTag {};
struct CTag {};

// 全局标签实例，方便调用
constexpr ATag a;
constexpr BTag b;
constexpr CTag c;

// 单个标签+值的处理函数
void fillX(X& obj, const ATag&, const string& val) { obj.a = val; }
void fillX(X& obj, const BTag&, const string& val) { obj.b = val; }
void fillX(X& obj, const CTag&, const string& val) { obj.c = val; }

// 递归终止函数
void fillX(X&) {}

// 可变参数模板，遍历所有参数并填充字段
template<typename T, typename... Args>
void fillX(X& obj, T&& arg, Args&&... args)
{
    fillX(obj, forward<T>(arg));
    fillX(obj, forward<Args>(args)...);
}

// 生成X对象的入口函数
template<typename... Args>
X generateTransaction(Args&&... args)
{
    X obj;
    fillX(obj, forward<Args>(args)...);
    return obj;
}

int main()
{
    auto x1 = generateTransaction(a, "first");
    auto x2 = generateTransaction(a, "abc", b, "second");
    auto x3 = generateTransaction(c, "third");
    auto x4 = generateTransaction(a, "test", c, "third");
    auto x5 = generateTransaction(a, "m", b, "n", c, "o");
    
    // 测试输出
    cout << x1.a << endl;
    cout << x2.b << endl;
    cout << x3.c << endl;
    cout << x4.a << " " << x4.c << endl;
    cout << x5.a << " " << x5.b << " " << x5.c << endl;
    
    return 0;
}

这个方案的优势是完全灵活：支持任意顺序、任意数量的字段赋值，而且编译期就能检查参数合法性（比如传错标签会直接编译报错），没有运行时开销。

方案二：Builder模式（更直观） #

如果结构体字段数量不多，Builder模式的可读性更好，不需要复杂的模板语法：

#include <iostream>
#include <string>

using namespace std;

struct X
{
    string a;
    string b;
    string c;
};

struct XBuilder
{
    X obj;
    
    // 链式调用的设置函数
    XBuilder& setA(const string& val) { obj.a = val; return *this; }
    XBuilder& setB(const string& val) { obj.b = val; return *this; }
    XBuilder& setC(const string& val) { obj.c = val; return *this; }
    
    // 生成最终对象
    X build() { return move(obj); }
};

int main()
{
    auto x1 = XBuilder().setA("first").build();
    auto x2 = XBuilder().setA("abc").setB("second").build();
    auto x3 = XBuilder().setC("third").build();
    auto x4 = XBuilder().setA("test").setC("third").build();
    auto x5 = XBuilder().setA("m").setB("n").setC("o").build();
    
    // 测试输出
    cout << x1.a << endl;
    cout << x2.b << endl;
    cout << x3.c << endl;
    cout << x4.a << " " << x4.c << endl;
    cout << x5.a << " " << x5.b << " " << x5.c << endl;
    
    return 0;
}

这种方式的调用代码非常直观，链式调用的逻辑一目了然，后续维护也更简单，适合字段固定且数量不多的场景。

方案三：可选参数（仅简单场景适用） #

如果只是想支持部分参数省略，也可以给函数参数设置默认值，但灵活性很差：

#include <iostream>
#include <string>

using namespace std;

struct X
{
    string a;
    string b;
    string c;
};

X generateTransaction(const string& a = "", const string& b = "", const string& c = "")
{
    X obj;
    if (!a.empty()) obj.a = a;
    if (!b.empty()) obj.b = b;
    if (!c.empty()) obj.c = c;
    return obj;
}

int main()
{
    // 缺点：无法跳过前面的参数直接传后面的，比如要给c赋值必须先传a、b的默认值
    auto x1 = generateTransaction("first");
    auto x2 = generateTransaction("abc", "second");
    auto x3 = generateTransaction("", "", "third");
    auto x4 = generateTransaction("test", "", "third");
    auto x5 = generateTransaction("m", "n", "o");
    
    return 0;
}

这个方案最简单，但只能按参数顺序传值，不能跳过前面的字段直接赋值后面的，适合需求很简单的场景，不推荐用于需要灵活传参的情况。

总结 #

• 如果你需要完全灵活的命名参数（任意顺序、任意字段组合），可变参数模板是合适的选择，编译期安全且无额外开销。
• 如果结构体字段数量不多，Builder模式的可读性和可维护性更好。
• 可选参数仅适合简单场景，灵活性不足，不推荐用于需要跳过参数的情况。

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