【C++ 泛型编程 高级篇】C++可变参数模板探索：编程技巧与实战应用

template <typename... Args>
class Tuple;

template <typename... Args>
void func(Args... args);

template <typename... Args>

void func(Args... args);

template <typename T, typename... Args>
void func(T head, Args... tail) {
    // 处理head参数
    // 递归展开剩余参数
    func(tail...);
}

template <typename... Args>
void func(Args... args) {
    constexpr size_t arg_count = sizeof...(Args);
    constexpr size_t arg_count = sizeof...(args);
    std::cout << "Number of arguments: " << arg_count << std::endl;
}

#include <iostream>
#include <tuple>
// 递归终止条件
template <typename T>
void print(T value) {
    std::cout << value << std::endl;
}
// 递归解包函数
template <typename T, typename... Args>
void print(T head, Args... tail) {
    std::cout << head << ", ";
    print(tail...);  // 递归调用，每次处理一个参数
}
// 使用 std::tuple 和 std::apply 遍历参数
template <typename... Args>
void print_with_tuple(Args... args) {
    auto args_tuple = std::make_tuple(args...);  // 将参数包转换为元组
    std::apply([](auto&&... args) {  // 使用 lambda 函数处理元组中的每个元素
        ((std::cout << args << ", "), ...);  // 使用逗号表达式和 fold expression 打印每个参数
    }, args_tuple);
}
int main() {
    print("Hello", "world", "this", "is", "C++");  // 使用递归解包打印参数
    print_with_tuple("Hello", "world", "this", "is", "C++");  // 使用 std::tuple 和 std::apply 打印参数
}

template <typename... Args>
void func(Args... args) {
    // 函数体
}

// 递归终止条件
template <typename T>
void print(T value) {
    std::cout << value << std::endl;
}
// 递归解包函数
template <typename T, typename... Args>
void print(T head, Args... tail) {
    std::cout << head << ", ";
    print(tail...);
}
int main() {
    print(1, 2.0, "Hello");
}

template <typename T>
void print(T value) {
    std::cout << value << std::endl;
}
template <typename T, typename... Args>
void print(T head, Args... tail) {
    std::cout << head << ", ";
    print(tail...);
}

template <typename... Args>
auto sum(Args... args) {
    return (... + args);
}
int main() {
    int result = sum(1, 2, 3, 4, 5);
    std::cout << "Sum: " << result << std::endl;
}

template <typename... Args>
auto sum(Args... args) {
    return (... + std::abs(args));  // 对每个参数调用 std::abs，然后求和
}

#include <iostream>
#include <sstream>
#include <string>
template <typename T>
std::string toString(const T &value) {
    std::ostringstream oss;
    oss << value;
    return oss.str();
}
template <typename... Args>
void print(Args... args) {
    // 使用折叠表达式将每个参数转换为字符串并连接在一起
    std::cout << (toString(args) + ... + "") << std::endl;
}
int main() {
    print(1, 2.0, "Hello", true);
    return 0;
}

template <typename... Ts>
struct Tuple;
template <typename T, typename... Ts>
struct Tuple<T, Ts...> : Tuple<Ts...> {
    T value;
    Tuple(T t, Ts... ts) : Tuple<Ts...>(ts...), value(t) {}
};
template <>
struct Tuple<> {};
int main() {
    Tuple<int, double, std::string> t(1, 2.0, "Hello");
}

#include <iostream>
#include <functional>
template <typename Func, typename... Args>
void callFunc(Func &&func, Args &&... args) {
    std::forward<Func>(func)(std::forward<Args>(args)...);
}
void print_sum(int a, int b) {
    std::cout << "Sum: " << a + b << std::endl;
}
int main() {
    callFunc(print_sum, 1, 2);
    callFunc([]() { std::cout << "Hello, world!" << std::endl; });
    return 0;
}

template <typename... Args>
class MyClass;

template <typename... Args>
class MyClass;

template <typename T, typename... Rest>
class Tuple : public Tuple<Rest...> {
public:
    explicit Tuple(T head, Rest... tail) : Tuple<Rest...>(tail...), head_(head) {}
    T head() const { return head_; }
private:
    T head_;
};
template <typename T>
class Tuple<T> {
public:
    explicit Tuple(T head) : head_(head) {}
    T head() const { return head_; }
private:
    T head_;
};

// 通用模板类
template <typename T, typename... Rest>
class MyClass {
public:
    void print() { std::cout << "General template" << std::endl; }
};
// 特化处理 int 参数
template <typename... Rest>
class MyClass<int, Rest...> {
public:
    void print() { std::cout << "Specialization for int" << std::endl; }
};
// 特化处理 float 参数
template <typename... Rest>
class MyClass<float, Rest...> {
public:
    void print() { std::cout << "Specialization for float" << std::endl; }
};

int main() {
    MyClass<int, float> obj1;
    MyClass<float, int> obj2;
    MyClass<double, char> obj3;
    obj1.print(); // 输出 "Specialization for int"
    obj2.print(); // 输出 "Specialization for float"
    obj3.print(); // 输出 "General template"
    return 0;
}

#include <iostream>
template <typename T, typename... Args>
class Printer {
public:
    void print(T first, Args... rest) {
        std::cout << first << " ";
        Printer<Args...>().print(rest...);
    }
};
template <typename T>
class Printer<T> {
public:
    void print(T first) {
        std::cout << first << std::endl;
    }
};

template <typename... Args>
void print_args(Args... args) {
    Printer<Args...>().print(args...);
}

int main() {
    print_args(1, 2.0, "Hello", 'A');
    print_args("Hello, World!", 42, 3.14);
    return 0;
}

template <typename T>
class Param {
public:
    Param(const T& value) : value_(value) {}
    const T& value() const { return value_; }
private:
    T value_;
};
template <typename T, typename... Rest>
class ParamList : public ParamList<Rest...>, public Param<T> {
public:
    ParamList(const T& head, const Rest&... tail) 
        : Param<T>(head), ParamList<Rest...>(tail...) {}
};
template <typename T>
class ParamList<T> : public Param<T> {
public:
    ParamList(const T& head) : Param<T>(head) {}
};

template <size_t index, typename ParamList>
struct ParamGetter;
template <typename T, typename... Rest>
struct ParamGetter<0, ParamList<T, Rest...>> {
    using type = T;
    static const T& get(const ParamList<T, Rest...>& list) {
        return list.value();
    }
};
template <size_t index, typename T, typename... Rest>
struct ParamGetter<index, ParamList<T, Rest...>> {
    using type = typename ParamGetter<index - 1, ParamList<Rest...>>::type;
    static const type& get(const ParamList<T, Rest...>& list) {
        return ParamGetter<index - 1, ParamList<Rest...>>::get(list);
    }
};

int main() {
    ParamList<int, float, std::string> params(42, 3.14f, "Hello, World!");
    int value1 = ParamGetter<0, decltype(params)>::get(params);
    float value2 = ParamGetter<1, decltype(params)>::get(params);
    std::string value3 = ParamGetter<2, decltype(params)>::get(params);
    std::cout << value1 << ", " << value2 << ", " << value3 << std::endl;
    return 0;
}

#include <iostream>
template <typename T>
constexpr T sum(T value) {
    return value;
}
template <typename T, typename... Args>
constexpr T sum(T first, Args... rest) {
    return first + sum(rest...);
}
int main() {
    constexpr int result = sum(1, 2, 3, 4, 5);
    std::cout << "Sum: " << result << std::endl;
    return 0;
}

#include <iostream>
template <typename T>
constexpr T product(T value) {
    return value;
}
template <typename T, typename... Args>
constexpr T product(T first, Args... rest) {
    return first * product(rest...);
}
int main() {
    constexpr int result = product(1, 2, 3, 4, 5);
    std::cout << "Product: " << result << std::endl;
    return 0;
}

#include <iostream>
#include <type_traits>
template <typename T, typename U>
constexpr bool are_same() {
    return std::is_same<T, U>::value;
}
template <typename T, typename U, typename... Args>
constexpr bool are_same() {
    return std::is_same<T, U>::value && are_same<U, Args...>();
}
int main() {
    constexpr bool all_same1 = are_same<int, int, int>();
    constexpr bool all_same2 = are_same<int, float, int>();
    std::cout << "All arguments are of the same type: ";
    if (all_same1) {
        std::cout << "Case 1 - true" << std::endl;
    } else {
        std::cout << "Case 1 - false" << std::endl;
    }
    if (all_same2) {
        std::cout << "Case 2 - true" << std::endl;
    } else {
        std::cout << "Case 2 - false" << std::endl;
    }
    return 0;
}

#include <memory>
#include <utility>
template <typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args) {
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

#include <iostream>
#include <functional>
template <typename F, typename... Args>
auto invoke(F&& func, Args&&... args) -> decltype(func(args...)) {
    return func(std::forward<Args>(args)...);
}
int main() {
    auto sum_lambda = [](int a, int b) { return a + b; };
    int result = invoke(sum_lambda, 5, 3);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

#include <iostream>
#include <string>
class MyClass {
public:
    MyClass(int a) : value_("int: " + std::to_string(a)) {}
    MyClass(float a) : value_("float: " + std::to_string(a)) {}
    MyClass(const std::string& a) : value_("string: " + a) {}
    template <typename T, typename... Args>
    MyClass(T&& first, Args&&... args) : MyClass(std::forward<T>(first)) {
    std::cout << "Delegate constructor called with " << sizeof...(Args) << " more arguments" << std::endl;
    }
    void print() {
    std::cout << value_ << std::endl;
    }
private:
std::string value_;
};
int main() {
    MyClass obj1(5);
    obj1.print();
    
    MyClass obj2(5.5f);
    obj2.print();
    
    MyClass obj3("hello");
    obj3.print();
    
    MyClass obj4(10, 5.5f, "world");
    obj4.print();
    
    return 0;
}

#include <iostream>
#include <utility>
#include <functional>
template <typename F>
class FunctionWrapper {
public:
    FunctionWrapper(F&& function) : func_(std::forward<F>(function)) {}
    template <typename... Args>
    auto operator()(Args&&... args) -> decltype(func_(std::forward<Args>(args)...)) {
        std::cout << "Before function call" << std::endl;
        auto result = func_(std::forward<Args>(args)...);
        std::cout << "After function call" << std::endl;
        return result;
    }
private:
    F func_;
};
template <typename F>
FunctionWrapper<F> make_function_wrapper(F&& function) {
    return FunctionWrapper<F>(std::forward<F>(function));
}
int my_function(int a, int b) {
    return a + b;
}
int main() {
    auto wrapped_function = make_function_wrapper(my_function);
    int result = wrapped_function(1, 2);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

#include <iostream>
#include <string>
#include <type_traits>
/**
 * @brief 递归辅助函数，处理打印的最后一个参数。
 *
 * @tparam T 参数类型。
 * @param lastArg 最后一个待打印参数。
 * @return std::string 打印结果字符串。
 */
template <typename T>
std::string print_one(const T& lastArg) {
    if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, const char*>) {
        return lastArg;
    } else {
        return std::to_string(lastArg);
    }
}
/**
 * @brief 类型安全的变长参数打印函数，可以处理任意数量和类型的参数。
 *
 * @tparam T 当前参数类型。
 * @tparam Args 剩余参数类型模板参数包。
 * @param first 当前参数。
 * @param rest 剩余参数。
 * @return std::string 打印结果字符串。
 */
template <typename T, typename... Args>
std::string print(const T& first, const Args&... rest) {
    if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, const char*>) {
        return first + " " + print(rest...);
    } else {
        return std::to_string(first) + " " + print(rest...);
    }
}
int main() {
    int a = 10;
    float b = 3.14f;
    std::string c = "hello";
    std::cout << print(a, b, c) << std::endl;
    return 0;
}

#include <iostream>
#include <type_traits>
#include <utility>
/**
 * @brief 基类A
 */
class A {
public:
    void funcA() {
        std::cout << "Function A" << std::endl;
    }
};
/**
 * @brief 基类B
 */
class B {
public:
    void funcB() {
        std::cout << "Function B" << std::endl;
    }
};
/**
 * @brief 基类C
 */
class C {
public:
    void funcC() {
        std::cout << "Function C" << std::endl;
    }
};
/**
 * @brief 可变参数模板类，实现多重继承的组合模式。
 *
 * @tparam Bases 基类类型模板参数包。
 */
template <typename... Bases>
class Composed : public Bases... {
public:
    /**
     * @brief 构造函数，初始化所有基类。
     *
     * @tparam Args 构造函数参数类型模板参数包。
     * @param args 构造函数参数。
     */
    template <typename... Args>
    explicit Composed(Args&&... args) : Bases(std::forward<Args>(args)...)... {}
};
int main() {
    // 通过多重继承组合A、B、C类的行为
    Composed<A, B, C> composed;
    composed.funcA();
    composed.funcB();
    composed.funcC();
    return 0;
}