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++语言特性的一个展示。
