C++装I3代码

1.以下是一段使用了模板元编程、lambda表达式和类型擦除等高级特性的C++代码，用于实现一个通用的函数，该函数可以接受任意数量的参数，并返回它们的和：

#include   
#include   
#include   
  
template  
auto sum(Args... args) -> decltype(std::declval() + ...) {  
    return (args + ...);  
}  
  
int main() {  
    std::cout << sum(1, 2, 3, 4, 5) << std::endl;      // 输出 15  
    std::cout << sum(1.0, 2.0, 3.0, 4.0, 5.0) << std::endl;  // 输出 15.0  
    std::cout << sum("Hello, ", "world!") << std::endl;  // 输出 "Hello, world!"  
    return 0;  
}

2.这次，我们将结合模板元编程、SFINAE（Substitution Failure Is Not An Error）、constexpr、以及用户自定义字面量来创建一个编译期的斐波那契数列生成器：

#include   
#include   
  
// 编译期斐波那契数列计算  
template  
struct Fibonacci {  
    static constexpr std::size_t value = Fibonacci::value + Fibonacci::value;  
};  
  
// 特化基础情形  
template<>  
struct Fibonacci<0> {  
    static constexpr std::size_t value = 0;  
};  
  
template<>  
struct Fibonacci<1> {  
    static constexpr std::size_t value = 1;  
};  
  
// 使用SFINAE来限制只能用于编译期常量  
template= 2), bool> = true>  
constexpr std::size_t fibonacci() {  
    return Fibonacci::value;  
}  
  
// 用户自定义字面量，用于在编译期计算斐波那契数  
constexpr std::size_t operator"" _fib(unsigned long long n) {  
    return fibonacci();  
}  
  
int main() {  
    // 注意：这里的计算都在编译期完成  
    std::cout << "Fibonacci(10) = " << 10_fib << std::endl; // 输出 Fibonacci(10) 的值  
    std::cout << "Fibonacci(20) = " << 20_fib << std::endl; // 输出 Fibonacci(20) 的值  
    std::cout << "Fibonacci(30) = " << 30_fib << std::endl; // 输出 Fibonacci(30) 的值  
    return 0;  
}

3.这次我们将使用模板元编程、SFINAE（Substitution Failure Is Not An Error）、完美转发以及C++17的结构化绑定等特性。这段代码将实现一个通用的函数，该函数能够根据传入参数的类型自动决定执行的操作，实现类似于C++中的std::variant的行为：

#include   
#include   
#include   
  
// 用于在编译时区分不同类型的tag  
struct IntTag {};  
struct FloatTag {};  
struct StringTag {};  
  
// 一个简单的访问者类模板，用于处理不同类型的值  
template   
struct Visitor;  
  
// 特化Visitor以处理int类型  
template <>  
struct Visitor {  
    void operator()(int value) const {  
        std::cout << "Visiting int: " << value << std::endl;  
    }  
};  
  
// 特化Visitor以处理float类型  
template <>  
struct Visitor {  
    void operator()(float value) const {  
        std::cout << "Visiting float: " << value << std::endl;  
    }  
};  
  
// 特化Visitor以处理std::string类型  
template <>  
struct Visitor {  
    void operator()(const std::string& value) const {  
        std::cout << "Visiting string: " << value << std::endl;  
    }  
};  
  
// 一个通用的Variant类模板，使用SFINAE和模板元编程实现  
template   
class Variant {  
public:  
    // 禁用拷贝和赋值  
    Variant(const Variant&) = delete;  
    Variant& operator=(const Variant&) = delete;  
  
    // 构造函数模板，接受任何类型的参数  
    template >>>  
    Variant(T&& value) : held_value(std::forward(value)), type_tag(std::is_same_v...) {}  
  
    // 访问函数，接受一个Visitor对象  
    template   
    void visit(VisitorType&& visitor) const {  
        using visitor_t = std::remove_reference_t;  
        if constexpr (std::is_same_v, int>) {  
            visitor(std::get<0>(held_value));  
        } else if constexpr (std::is_same_v, float>) {  
            visitor(std::get<1>(held_value));  
        } else if constexpr (std::is_same_v, std::string>) {  
            visitor(std::get<2>(held_value));  
        }  
    }  
  
private:  
    // 使用std::variant来实际存储值，这里为了演示目的手动实现了类型标签  
    std::variant held_value;  
    std::tuple type_tag;  
};  
  
int main() {  
    // 创建一个Variant对象  
    Variant variant;  
  
    // 初始化为int类型  
    variant = 42;  
  
    // 使用lambda作为访问者来访问值  
    variant.visit([](auto&& value) {  
        using ValueType = std::decay_t;  
        if constexpr (std::is_same_v) {  
            std::cout << "Int value: " << value << std::endl;  
        } else if constexpr (std::is_same_v) {  
            std::cout << "Float value: " << value << std::endl;  
        } else if constexpr (std::is_same_v) {  
            std::cout << "String value: " << value << std::endl;  
        }  
    });  
  
    // 初始化为float类型  
    variant = 3.14f;  
  
    // 使用lambda作为访问者来访问值  
    variant.visit([](auto&& value) {  
        using ValueType = std::decay_t;  
        if constexpr (std::is_same_v) {  
            std::cout << "Int value: " << value << std::endl;  
        } else if constexpr (std::

4.以下是一段使用模板元编程、constexpr、完美转发和递归的C++代码，它实现了一个模板函数，该函数可以在编译时计算阶乘：

#include   
#include   
  
// 递归基准情况：0的阶乘是1  
template<>  
constexpr unsigned long long factorial<0>() {  
    return 1;  
}  
  
// 递归情况：计算n的阶乘  
template  
constexpr unsigned long long factorial() {  
    return n * factorial();  
}  
  
// 完美转发版本，接受任何整数类型并转换为unsigned int  
template::value>::type>  
constexpr unsigned long long factorial(T value) {  
    return factorial(value)>();  
}  
  
int main() {  
    // 在编译时计算5的阶乘  
    constexpr unsigned long long fiveFactorial = factorial(5);  
    std::cout << "5! = " << fiveFactorial << std::endl; // 输出 5! = 120  
  
    // 在编译时计算10的阶乘  
    constexpr unsigned long long tenFactorial = factorial(10);  
    std::cout << "10! = " << tenFactorial << std::endl; // 输出 10! = 3628800  
  
    return 0;  
}

在这段代码中，我们定义了一个模板函数factorial，它使用递归在编译时计算阶乘。我们为n = 0的情况提供了一个特化版本，作为递归的基准情况。对于其他情况，我们使用了模板元编程来在编译时展开递归计算。此外，我们还提供了一个接受任何整数类型参数的完美转发版本，并使用std::enable_if和std::is_integral来确保只接受整数类型。

这段代码展示了C++在模板元编程、类型推断和完美转发方面的强大能力，以及如何在编译时执行计算以获得更好的性能。当然，在实际开发中，通常会避免在编译时执行复杂的计算，因为这可能会增加编译时间。但是，这段代码确实可以作为C++语言特性的一个展示。

都看到这里了，要个免费的赞赞不过分吧