C++ Programming Labs

Your Task: Learn constexpr - a powerful C++11/14/17 feature that enables compile-time computation, improving performance and enabling use in template arguments.

Detailed Requirements:
1. Basic constexpr function:
constexpr int square(int n) { return n * n; } // Computed at compile time! constexpr int result = square(5); // 25

2. Constexpr with conditionals (C++14+):
constexpr int factorial(int n) { if (n <= 1) return 1; return n * factorial(n - 1); } constexpr int fact5 = factorial(5); // 120

3. Constexpr variables:
constexpr double PI = 3.14159265358979; constexpr double circle_area(double r) { return PI * r * r; }

4. Constexpr with arrays (C++17):
constexpr int fibonacci(int n) { if (n <= 1) return n; return fibonacci(n-1) + fibonacci(n-2); } // Use in array size int arr[fibonacci(10)]; // Size 55

Expected Output:
Square of 5: 25 Factorial of 6: 720 Circle area (r=3): 28.2743 Fibonacci(10): 55 All computed at compile time!

Your Task: Use <type_traits> to query and manipulate types at compile time. Essential for template metaprogramming.

Detailed Requirements:
1. Include type_traits header:
#include <type_traits>

2. Check type properties:
cout << is_integral::value << endl; // 1 (true) cout << is_floating_point::value; // 1 (true) cout << is_pointer::value << endl; // 1 (true) cout << is_class::value << endl; // 1 (true)

3. Use static_assert for compile-time checks:
template void process(T value) { static_assert(is_integral::value, "T must be an integral type"); // ... process integer }

4. Type transformations:
// Remove const/reference remove_const::type x; // int remove_reference::type y; // int // Add const/pointer add_const::type z; // const int add_pointer::type p; // int*

5. Conditional types:
// Choose type based on condition conditional::type a; // int conditional::type b; // double

Expected Output:
int is integral: true double is floating: true int* is pointer: true string is class: true Types validated at compile time!

Your Task: Master variadic templates - templates that accept any number of arguments. Used in std::tuple, std::make_unique, and more.

Detailed Requirements:
1. Parameter pack syntax:
// typename... is parameter pack template void func(Args... args) { // args... is pack expansion }

2. Count arguments with sizeof...:
template void count_args(Args... args) { cout << "Count: " << sizeof...(Args) << endl; } count_args(1, 2, 3, 4); // Count: 4

3. Print all arguments (recursive):
// Base case void print() { cout << endl; } // Recursive case template void print(T first, Rest... rest) { cout << first << " "; print(rest...); // Recurse with remaining }

4. Fold expressions (C++17):
template auto sum(Args... args) { return (args + ...); // Fold over + } cout << sum(1, 2, 3, 4); // 10

Expected Output:
Argument count: 4 Printing: 1 2 3 hello Sum: 15 Product: 120