MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

C++可变参数模板的参数包操作

2021-02-122.8k 阅读

C++ 可变参数模板的参数包操作

1. 可变参数模板简介

在 C++11 引入可变参数模板之前，处理数量不定的参数是一件颇为棘手的事情。例如，传统的 printf 函数通过 ... 来接受可变参数，但它依赖于 va_start、va_arg 和 va_end 等宏，不仅使用复杂，而且类型安全难以保证。

可变参数模板允许定义接受可变数量参数的模板函数和模板类。参数包（parameter pack）是可变参数模板的核心概念，它可以包含零个或多个模板参数。

2. 参数包的声明与展开

2.1 参数包声明

在模板参数列表中，使用省略号 ... 来声明参数包。例如，定义一个接受可变数量参数的模板函数：

template <typename... Args>
void print(Args... args) {
    // 这里还未实现具体打印逻辑
}

在上述代码中，Args 是一个类型参数包，它可以表示零个或多个类型。args 是一个值参数包，对应于具体的参数值。

2.2 参数包展开

参数包必须被展开才能使用其中的参数。有几种常见的展开方式。

递归展开：通过递归调用模板函数来展开参数包。

#include <iostream>

template <typename T>
void print_single(T t) {
    std::cout << t << std::endl;
}

template <typename First, typename... Rest>
void print(First first, Rest... rest) {
    print_single(first);
    print(rest...);
}

template <>
void print<>() {
    // 递归终止条件
}

int main() {
    print(1, "hello", 3.14);
    return 0;
}

在上述代码中，print 函数的第一个版本接受一个参数 first 和参数包 rest。它首先打印 first，然后递归调用 print 来处理 rest 中的参数。当 rest 为空时，调用无参数版本的 print 作为递归终止条件。

折叠表达式（C++17 引入）：一种更简洁的展开参数包的方式。例如，计算可变数量参数的和：

#include <iostream>

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

int main() {
    auto result = sum(1, 2, 3, 4);
    std::cout << "Sum is: " << result << std::endl;
    return 0;
}

这里 (... + args) 是一个折叠表达式，它将参数包 args 中的所有参数进行加法运算。折叠表达式有左折叠和右折叠之分，(... + args) 是左折叠，等价于 (args1 + (args2 + (... + argsN)))。右折叠则是 ((args1 + args2) +... + argsN)，表示为 (args +...)。

3. 参数包在模板类中的应用

3.1 定义可变参数模板类

可变参数模板类在某些场景下非常有用，例如实现一个元组（tuple）。

template <typename... Types>
class MyTuple;

template <>
class MyTuple<> {
};

template <typename Head, typename... Tail>
class MyTuple<Head, Tail...> : private MyTuple<Tail...> {
    Head data;
public:
    MyTuple(Head h, Tail... t) : MyTuple<Tail...>(t...), data(h) {
    }

    Head get_head() const {
        return data;
    }

    MyTuple<Tail...>& get_tail() {
        return *this;
    }
};

在上述代码中，MyTuple 是一个可变参数模板类。空参数版本的 MyTuple 作为递归的基础情况。非空参数版本继承自 MyTuple<Tail...>，并包含一个类型为 Head 的数据成员 data。构造函数用于初始化数据成员和基类。

3.2 参数包在模板类继承中的应用

通过参数包在继承体系中传递参数，可以实现灵活的层次结构。例如，定义一个日志记录类层次结构：

class LoggerBase {
public:
    virtual void log(const std::string& message) = 0;
};

template <typename... Loggers>
class CompositeLogger : public LoggerBase, private Loggers... {
public:
    template <typename... Args>
    CompositeLogger(Args... args) : Loggers(args)... {
    }

    void log(const std::string& message) override {
        (void)std::initializer_list<int>{(Loggers::log(message), 0)...};
    }
};

class ConsoleLogger : public LoggerBase {
public:
    void log(const std::string& message) override {
        std::cout << "Console: " << message << std::endl;
    }
};

class FileLogger : public LoggerBase {
public:
    void log(const std::string& message) override {
        std::ofstream file("log.txt", std::ios::app);
        file << "File: " << message << std::endl;
        file.close();
    }
};

在上述代码中，CompositeLogger 继承自多个 Logger 类型（由参数包 Loggers 表示）。log 函数通过折叠表达式调用所有继承的 Logger 对象的 log 函数。

4. 参数包的解包与转发

4.1 完美转发

在 C++ 中，完美转发是指函数模板能够将其参数原封不动地转发给其他函数。结合可变参数模板，这一特性变得更加强大。

#include <iostream>
#include <functional>

template <typename F, typename... Args>
void forwarder(F&& f, Args&&... args) {
    std::forward<F>(f)(std::forward<Args>(args)...);
}

void func(int i, double d) {
    std::cout << "func called with " << i << " and " << d << std::endl;
}

int main() {
    forwarder(func, 10, 3.14);
    return 0;
}

在上述代码中，forwarder 函数接受一个可调用对象 f 和可变参数包 args。通过 std::forward，它能够将参数完美转发给 f，保持参数的左值或右值属性。

4.2 参数包解包与类型推导

有时候，需要根据参数包中的参数类型进行不同的操作。例如，实现一个函数，根据参数类型进行不同的打印：

#include <iostream>
#include <type_traits>

void print_int(int i) {
    std::cout << "Integer: " << i << std::endl;
}

void print_double(double d) {
    std::cout << "Double: " << d << std::endl;
}

template <typename... Args>
void print_different_types(Args... args) {
    (void)std::initializer_list<int>{(
        [&args]() {
            if constexpr (std::is_same_v<std::decay_t<decltype(args)>, int>) {
                print_int(args);
            } else if constexpr (std::is_same_v<std::decay_t<decltype(args)>, double>) {
                print_double(args);
            }
            return 0;
        }(), 0
    )...};
}

int main() {
    print_different_types(10, 3.14, 20);
    return 0;
}

在上述代码中，print_different_types 函数通过折叠表达式和解包参数包，根据每个参数的类型调用不同的打印函数。if constexpr 是 C++17 引入的编译期条件判断，用于在编译期根据类型进行不同的操作。

5. 参数包操作的性能优化

5.1 减少模板实例化

过多的模板实例化会导致编译时间增长和代码体积膨胀。在使用可变参数模板时，尽量减少不必要的模板实例化。例如，在递归展开参数包时，可以通过 if constexpr 进行编译期条件判断，避免某些不必要的实例化。

template <typename... Args>
void print_optimized(Args... args) {
    if constexpr (sizeof...(args) > 0) {
        auto first = {args...};
        print_single(first);
        print_optimized({(args,...)});
    }
}

在上述代码中，if constexpr 确保只有在参数包不为空时才进行递归调用，减少了不必要的模板实例化。

5.2 利用编译期计算

利用编译期计算可以避免运行时开销。例如，在计算可变数量参数的乘积时，可以使用编译期递归：

template <typename T, T... values>
struct Product {
    static const T value;
};

template <typename T, T first, T... rest>
struct Product<T, first, rest...> {
    static const T value = first * Product<T, rest...>::value;
};

template <typename T, T value>
struct Product<T, value> {
    static const T value = value;
};

在上述代码中，Product 模板类通过编译期递归计算参数包中所有值的乘积，在编译期就完成了计算，避免了运行时的循环开销。

6. 可变参数模板在库中的应用

6.1 std::apply

std::apply 是 C++17 标准库中的一个函数，它将一个可调用对象应用到一个元组的元素上。其实现就利用了可变参数模板。

#include <iostream>
#include <tuple>
#include <utility>

template <typename F, typename Tuple, std::size_t... I>
constexpr decltype(auto) apply_impl(F&& f, Tuple&& t, std::index_sequence<I...>) {
    return std::invoke(std::forward<F>(f), std::get<I>(std::forward<Tuple>(t))...);
}

template <typename F, typename Tuple>
constexpr decltype(auto) apply(F&& f, Tuple&& t) {
    return apply_impl(std::forward<F>(f), std::forward<Tuple>(t), std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>{});
}

int main() {
    auto t = std::make_tuple(1, 2, 3);
    auto sum = apply([](int a, int b, int c) { return a + b + c; }, t);
    std::cout << "Sum is: " << sum << std::endl;
    return 0;
}

在上述代码中，apply_impl 函数通过可变参数模板和 std::index_sequence 展开元组的元素，并将其传递给可调用对象 f。apply 函数则负责生成 std::index_sequence 并调用 apply_impl。

6.2 std::variant

std::variant 是 C++17 引入的类型安全的联合类型，它也使用了可变参数模板。std::variant 可以存储多个不同类型中的一种类型的值。

#include <iostream>
#include <variant>

int main() {
    std::variant<int, double, std::string> var;
    var = 10;
    std::visit([](auto&& arg) {
        if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, int>) {
            std::cout << "Value is int: " << arg << std::endl;
        } else if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, double>) {
            std::cout << "Value is double: " << arg << std::endl;
        } else if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, std::string>) {
            std::cout << "Value is string: " << arg << std::endl;
        }
    }, var);

    var = 3.14;
    std::visit([](auto&& arg) {
        if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, int>) {
            std::cout << "Value is int: " << arg << std::endl;
        } else if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, double>) {
            std::cout << "Value is double: " << arg << std::endl;
        } else if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, std::string>) {
            std::cout << "Value is string: " << arg << std::endl;
        }
    }, var);

    var = "hello";
    std::visit([](auto&& arg) {
        if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, int>) {
            std::cout << "Value is int: " << arg << std::endl;
        } else if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, double>) {
            std::cout << "Value is double: " << arg << std::endl;
        } else if constexpr (std::is_same_v<std::decay_t<decltype(arg)>, std::string>) {
            std::cout << "Value is string: " << arg << std::endl;
        }
    }, var);

    return 0;
}

在上述代码中，std::variant 可以存储 int、double 或 std::string 类型的值。std::visit 函数接受一个可调用对象，根据 std::variant 当前存储的值的类型来调用相应的逻辑。其实现内部利用了可变参数模板来处理不同类型的可能性。

7. 总结可变参数模板的参数包操作要点

  • 参数包声明与展开：通过 ... 声明参数包，使用递归、折叠表达式等方式展开参数包。
  • 模板类应用：在模板类中利用参数包实现灵活的数据结构和继承体系。
  • 解包与转发：通过完美转发和类型推导，实现参数的高效传递和根据类型的不同操作。
  • 性能优化：减少模板实例化，利用编译期计算提升性能。
  • 库中的应用：理解标准库中如 std::apply、std::variant 等如何利用可变参数模板实现强大的功能。

通过深入理解和熟练运用可变参数模板的参数包操作，开发者能够编写出更加通用、灵活和高效的 C++ 代码。无论是在实现自定义的数据结构，还是在优化性能关键的代码路径上，可变参数模板都提供了强大的工具。在实际应用中，需要根据具体的需求和场景，合理选择参数包的展开方式、利用编译期特性，并注意避免模板实例化带来的潜在问题。