C++17新特性：std::tuple及其相关功能解析

#include <iostream>
#include <tuple>

int main() {
    // 创建一个包含int、double和std::string类型元素的std::tuple对象
    std::tuple<int, double, std::string> t(1, 2.5, "Hello");

    // 访问元素：使用std::get函数模板，通过索引来访问tuple中的元素
    std::cout << std::get<0>(t) << ", " << std::get<1>(t) << ", " << std::get<2>(t) << std::endl;

    // 修改元素：同样使用std::get函数模板获取元素的引用，然后进行修改
    std::get<0>(t) = 10;
    std::cout << std::get<0>(t) << std::endl;

    return 0;
}

// 默认构造：创建一个包含默认初始化元素的std::tuple对象
std::tuple<int, double, std::string> t1; 

// 列表初始化：通过提供具体的元素值来初始化std::tuple对象
std::tuple<int, double, std::string> t2(1, 2.5, "Hello"); 

// 拷贝构造：使用已有的std::tuple对象来创建一个新的副本
std::tuple<int, double, std::string> t3 = t2; 

#include <iostream>
#include <tuple>
#include <functional>

int main() {
    std::tuple<int, double, std::string> t(1, 2.5, "Hello");

    // 使用std::apply将tuple中的元素解包并传递给一个lambda函数
    std::apply([](int a, double b, std::string c) {
        std::cout << a << ", " << b << ", " << c << std::endl;
    }, t);

    return 0;
}

#include <iostream>
#include <tuple>
#include <functional>

struct MyClass {
    MyClass(int a, double b, std::string c) {
        std::cout << "Constructed with: " << a << ", " << b << ", " << c << std::endl;
    }
};

int main() {
    std::tuple<int, double, std::string> t(1, 2.5, "Hello");

    // 使用std::apply调用MyClass的构造函数
    std::apply([](auto... args) { return MyClass(args...); }, t);

    return 0;
}

#include <iostream>
#include <tuple>
#include <string>

struct Person {
    int age;
    double height;
    std::string name;

    Person(int a, double b, std::string c) : age(a), height(b), name(c) {}
};

int main() {
    std::tuple<int, double, std::string> t(30, 1.75, "John");

    // 使用std::make_from_tuple从tuple构造一个Person对象
    Person p = std::make_from_tuple<Person>(t);

    std::cout << p.age << ", " << p.height << ", " << p.name << std::endl;

    return 0;
}

#include <iostream>
#include <tuple>
#include <string>
#include <memory>

class Shape {
public:
    virtual void draw() const = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    void draw() const override {
        std::cout << "Drawing a circle with radius " << radius << std::endl;
    }
};

class Rectangle : public Shape {
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    void draw() const override {
        std::cout << "Drawing a rectangle with width " << width << " and height " << height << std::endl;
    }
};

template<typename T, typename Tuple>
std::unique_ptr<T> createShape(Tuple&& args) {
    return std::make_unique<T>(std::make_from_tuple<T>(std::forward<Tuple>(args)));
}

int main() {
    auto circleArgs = std::make_tuple(5.0);
    auto circle = createShape<Circle>(circleArgs);
    circle->draw();

    auto rectangleArgs = std::make_tuple(3.0, 4.0);
    auto rectangle = createShape<Rectangle>(rectangleArgs);
    rectangle->draw();

    return 0;
}

#include <iostream>
#include <tuple>

template <typename... Args>
struct MyTuple {
    std::tuple<Args...> data;
};

// 推导指南：根据传入的参数类型推导MyTuple的模板参数类型
template <typename... Args>
MyTuple(Args&&... args) -> MyTuple<std::decay_t<Args>...>;

int main() {
    // 不需要显式指定模板参数类型，编译器会根据传入的参数自动推导
    MyTuple t(1, 2.5, "Hello");

    std::cout << std::get<0>(t.data) << ", " << std::get<1>(t.data) << ", " << std::get<2>(t.data) << std::endl;

    return 0;
}

#include <iostream>
#include <vector>

template<typename T>
class Container {
    std::vector<T> data;
public:
    Container(const std::vector<T>& v) : data(v) {}
    void print() const {
        for (const auto& element : data) {
            std::cout << element << " ";
        }
        std::cout << std::endl;
    }
};

// 推导指南：根据传入的std::vector的元素类型推导Container的模板参数类型
template<typename T>
Container(const std::vector<T>&) -> Container<T>;

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    // 不需要显式指定模板参数类型，编译器会根据传入的std::vector自动推导
    Container container(vec);
    container.print();

    return 0;
}

#include <iostream>
#include <any>

int main() {
    // 创建std::any对象并存储不同类型的数据
    std::any a = 1;
    std::any b = 2.5;
    std::any c = "Hello";

    // 使用std::any_cast访问存储的数据
    if (a.type() == typeid(int)) {
        std::cout << std::any_cast<int>(a) << std::endl;
    }

    if (b.type() == typeid(double)) {
        std::cout << std::any_cast<double>(b) << std::endl;
    }

    if (c.type() == typeid(const char*)) {
        std::cout << std::any_cast<const char*>(c) << std::endl;
    }

    return 0;
}

#include <iostream>
#include <any>
#include <unordered_map>
#include <string>

// 配置文件解析器类
class ConfigParser {
    std::unordered_map<std::string, std::any> configMap;
public:
    void addConfig(const std::string& key, const std::any& value) {
        configMap[key] = value;
    }

    template<typename T>
    T getConfig(const std::string& key) const {
        auto it = configMap.find(key);
        if (it != configMap.end() && it->second.type() == typeid(T)) {
            return std::any_cast<T>(it->second);
        }
        throw std::runtime_error("Config key not found or wrong type");
    }
};

int main() {
    ConfigParser parser;
    parser.addConfig("port", 8080);
    parser.addConfig("timeout", 5.0);
    parser.addConfig("server_name", std::string("example.com"));

    try {
        int port = parser.getConfig<int>("port");
        double timeout = parser.getConfig<double>("timeout");
        std::string serverName = parser.getConfig<std::string>("server_name");

        std::cout << "Port: " << port << std::endl;
        std::cout << "Timeout: " << timeout << std::endl;
        std::cout << "Server Name: " << serverName << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}