第二节 · 安全部门 · 异常处理库

C++11 的可变参数模板和 C++17 的折叠表达式让函数能够接受任意数量的参数。

---

C 风格可变参数

#include <cstdarg>

// 旧的方式，不类型安全
double average(int count, ...)
{
    va_list args;
    va_start(args, count);
    
    double sum = 0;
    for (int i = 0; i < count; ++i)
    {
        sum += va_arg(args, double);
    }
    
    va_end(args);
    return sum / count;
}

int main()
{
    cout << average(3, 1.0, 2.0, 3.0) << endl;  // 2
    return 0;
}

---

可变参数模板

// 递归终止
void print()
{
    cout << endl;
}

// 递归展开
template<typename T, typename... Args>
void print(T first, Args... rest)
{
    cout << first << " ";
    print(rest...);
}

int main()
{
    print(1, 2.0, "three", '4');
    // 输出：1 2 three 4
    
    return 0;
}

---

sizeof... 运算符

template<typename... Args>
void info(Args... args)
{
    cout << "Number of arguments: " << sizeof...(Args) << endl;
    cout << "Number of arguments: " << sizeof...(args) << endl;
}

int main()
{
    info(1, 2, 3);       // 3
    info("a", "b");      // 2
    info();              // 0
    
    return 0;
}

---

折叠表达式（C++17）

// 左折叠：(... op pack) => ((arg1 op arg2) op arg3) ...
// 右折叠：(pack op ...) => arg1 op (arg2 op (arg3 ...))

template<typename... Args>
auto sum(Args... args)
{
    return (... + args);  // 左折叠
}

template<typename... Args>
auto product(Args... args)
{
    return (args * ...);  // 右折叠
}

template<typename... Args>
void printAll(Args... args)
{
    ((cout << args << " "), ...);  // 逗号折叠
    cout << endl;
}

int main()
{
    cout << sum(1, 2, 3, 4, 5) << endl;      // 15
    cout << product(1, 2, 3, 4, 5) << endl;  // 120
    printAll("Hello", 42, 3.14);
    
    return 0;
}

---

带初始值的折叠

// (init op ... op pack)
// (pack op ... op init)

template<typename... Args>
auto sumWithInit(Args... args)
{
    return (0 + ... + args);  // 初始值 0
}

template<typename... Args>
bool allTrue(Args... args)
{
    return (true && ... && args);
}

template<typename... Args>
bool anyTrue(Args... args)
{
    return (false || ... || args);
}

int main()
{
    cout << sumWithInit() << endl;        // 0（空参数列表）
    cout << allTrue(true, true, false) << endl;  // 0
    cout << anyTrue(false, true, false) << endl; // 1
    
    return 0;
}

---

可变参数构造

template<typename T>
class Container
{
    vector<T> data;
    
public:
    template<typename... Args>
    Container(Args&&... args)
        : data{forward<Args>(args)...}  // 初始化列表展开
    {
    }
    
    void print() const
    {
        for (const auto& x : data)
            cout << x << " ";
        cout << endl;
    }
};

int main()
{
    Container<int> c(1, 2, 3, 4, 5);
    c.print();  // 1 2 3 4 5
    
    return 0;
}

---

emplace 系列函数

class Person
{
public:
    string name;
    int age;
    
    Person(string n, int a) : name(move(n)), age(a)
    {
        cout << "Constructed: " << name << endl;
    }
};

int main()
{
    vector<Person> people;
    
    // push_back 需要先构造对象
    people.push_back(Person("Alice", 25));
    
    // emplace_back 直接在容器内构造
    people.emplace_back("Bob", 30);  // 更高效
    
    return 0;
}

---

转发所有参数

template<typename T, typename... Args>
unique_ptr<T> myMakeUnique(Args&&... args)
{
    return unique_ptr<T>(new T(forward<Args>(args)...));
}

class Widget
{
public:
    Widget(int a, string b, double c)
    {
        cout << "Widget(" << a << ", " << b << ", " << c << ")" << endl;
    }
};

int main()
{
    auto w = myMakeUnique<Widget>(42, "hello", 3.14);
    return 0;
}

---

类型安全的 printf

template<typename T>
void format_impl(ostream& os, const char* fmt, T value)
{
    while (*fmt)
    {
        if (*fmt == '%' && *(fmt + 1) != '%')
        {
            os << value;
            return;
        }
        os << *fmt++;
    }
}

void format(ostream& os, const char* fmt)
{
    os << fmt;
}

template<typename T, typename... Args>
void format(ostream& os, const char* fmt, T value, Args... args)
{
    while (*fmt)
    {
        if (*fmt == '%' && *(fmt + 1) != '%')
        {
            os << value;
            format(os, fmt + 2, args...);
            return;
        }
        os << *fmt++;
    }
}

int main()
{
    format(cout, "Name: %, Age: %, Score: %\n", "Alice", 25, 95.5);
    return 0;
}

---

元组辅助

#include <tuple>

// 打印元组
template<typename Tuple, size_t... Is>
void printTupleImpl(const Tuple& t, index_sequence<Is...>)
{
    ((cout << (Is == 0 ? "" : ", ") << get<Is>(t)), ...);
}

template<typename... Args>
void printTuple(const tuple<Args...>& t)
{
    cout << "(";
    printTupleImpl(t, index_sequence_for<Args...>{});
    cout << ")" << endl;
}

int main()
{
    auto t = make_tuple(1, "hello", 3.14);
    printTuple(t);  // (1, hello, 3.14)
    
    return 0;
}

---

习题

• 实现一个 min 函数，接受任意数量的参数并返回最小值。

• 使用折叠表达式实现字符串拼接函数。

• 实现类型安全的 printf 替代品。