C++ 的新生

#include <iostream>
#include <string>
#include <boost/pfr.hpp>

struct Person {
    std::string name;
    int age;
};

void print_person(const Person& p) {
    boost::pfr::for_each_field(p, [](const auto& field, size_t idx) {
        std::cout << "Member " << idx << ": " << field << '\n';
    });
}

int main() {
    Person p{"John Doe", 30};
    print_person(p); // 输出 name 和 age 成员
}

#include <iostream>
#include <string>
#include <meta>

struct Person {
    std::string name;
    int age;
};

template<typename T>
void print_struct(const T& value) {
    // 步骤 1：自省 (Introspection)
    // 使用 ^^ 运算符获取类型 T 的元信息，并查询其所有非静态成员。
    constexpr auto members = std::meta::nonstatic_data_members_of(^^T);

    std::cout << "{ ";
    // 像遍历普通数组一样遍历成员元信息
    for (auto member_info : members) {
        // 步骤 2 & 3：查询 (Querying) 与 生成 (Generation)
        // 使用元函数 identifier_of 查询成员名称，
        // 并使用注入器 [:member_info:] 生成访问成员的代码 (value.name, value.age)。
        std::cout << std::meta::identifier_of(member_info) << ": "
                  << value.[:member_info:] << "; ";
    }
    std::cout << "}\n";
}

int main() {
    Person p{"Jane Doe", 28};
    print_struct(p); // 输出: { name: Jane Doe; age: 28; }
}

template<typename T>
bool operator==(const T& lhs, const T& rhs) {
    // 获取类型T的所有成员
    constexpr auto members = std::meta::nonstatic_data_members_of(^^T);
    // 遍历所有成员，逐一比较
    for (auto member : members) {
        if (lhs.[:member:] != rhs.[:member:]) {
            return false;
        }
    }
    return true;
}

std::unique_ptr<Shape> create_shape(const std::string& name) {
    // 假设有一个编译期生成的从字符串到类型信息的映射
    constexpr auto type_map = generate_type_map(); 
    
    if (auto it = type_map.find(name); it != type_map.end()) {
        // it->second 是一个 std::meta::info
        // 使用注入器 [:...:] 创建该类型的实例
        return std::make_unique<[:it->second:]>();
    }
    return nullptr;
}

#include <iostream>
#include <string>
#include <meta>

// 假设有一个简单的JSON构建器...

template<typename T>
std::string to_json(const T& obj) {
    JsonBuilder builder;
    constexpr auto members = std::meta::nonstatic_data_members_of(^^T);
    for (auto member : members) {
        builder.add(std::meta::identifier_of(member), obj.[:member:]);
    }
    return builder.finalize();
}

struct User {
    int id;
    std::string username;
    bool is_active;
};

int main() {
    User u{101, "alex", true};
    std::cout << to_json(u) << std::endl;
}

#include <iostream>
#include <string>
#include <map>
#include <variant>
#include <meta>

// --- 为构成完整示例所需的模拟代码 ---
using JsonValue = std::variant<int, bool, std::string>;
using JsonObject = std::map<std::string, JsonValue>;

template<typename T>
T to_type(const JsonValue& val);

template<>
int to_type<int>(const JsonValue& val) { return std::get<int>(val); }
template<>
bool to_type<bool>(const JsonValue& val) { return std::get<bool>(val); }
template<>
std::string to_type<std::string>(const JsonValue& val) { return std::get<std::string>(val); }
// --- 模拟代码结束 ---

struct User {
    int id;
    std::string username;
    bool is_active;
};

template<typename T>
T from_json(const JsonObject& json) {
    T obj;
    constexpr auto members = std::meta::nonstatic_data_members_of(^^T);
    for (auto member : members) {
        const auto name = std::string(std::meta::identifier_of(member));
        if (json.count(name)) {
            obj.[:member:] = to_type<[:std::meta::type_of(member):]>(json.at(name));
        }
    }
    return obj;
}

int main() {
    JsonObject user_json = {
        {"id", 101},
        {"username", std::string("alex")},
        {"is_active", true}
    };

    User u = from_json<User>(user_json);

    std::cout << "User ID: " << u.id << std::endl;
    std::cout << "Username: " << u.username << std::endl;
    std::cout << std::boolalpha << "Is Active: " << u.is_active << std::endl;
    return 0;
}

template<typename T>
std::string generate_create_table_sql() {
    std::string sql = "CREATE TABLE " + std::string(std::meta::identifier_of(^^T)) + " (";
    constexpr auto members = std::meta::nonstatic_data_members_of(^^T);
    bool first = true;
    for (auto member : members) {
        if (!first) sql += ", ";
        sql += std::meta::identifier_of(member);
        // 此处可以根据 std::meta::type_of(member) 映射到 SQL 类型
        // 例如，^^int -> " INTEGER", ^^std::string -> " TEXT"
        //... 简化处理...
        sql += " TEXT";
        first = false;
    }
    sql += ");";
    return sql;
}

struct Product {
    int product_id;
    std::string name;
    double price;
};

int main() {
    std::cout << generate_create_table_sql<Product>() << std::endl;
    // 可能输出: CREATE TABLE Product (product_id TEXT, name TEXT, price TEXT);
}

#include "clap.hpp" // 假设的反射驱动的库

struct Args {
    [[short_name("n"), long_name("name")]]
    std::string name;

    [[help("Number of times to repeat the greeting")]]
    [[long_name("count")]]
    int count = 1;
};

int main(int argc, char** argv) {
    auto args = clap::parse<Args>(argc, argv);
    for (int i = 0; i < args.count; ++i) {
        std::cout << "Hello, " << args.name << "!\n";
    }
}