庞大的数据结构，返回结果有多大开销？
【 在 hgoldfish 的大作中提到: 】
: 这种情况怎么会用指针？
: 用值语义非常方便。
: c++ 如今有 move 语义，这种传递数据最佳的方案就是直接返回结果，别让客户把指针传进来。虽然底层也可以理解成指针，但配合 RAII 或者 uniqure_ptr，应用层的程度员不再需要管指针了。
: ...................
--
FROM 114.244.128.*

对于52楼的问题，你有何高招，解决一个泛型工具，完成一个通用的SQL操作，简单的，就来一个通用的insert吧。
能够提供的参数有：数据库句柄，表名，含有数据的数据结构，允许使用某种形式的模板。
我的形式如下：
int SQL_insert(数据库句柄，void ＊data,模板，用于生成语句的buffer）；
模板里有表名。buffer是因为我不知道语句需要多长，由用户提供，够长就行。全是指针。
可以让AI弄一下。

【 在 z16166 的大作中提到: 】
: 如果还需要c_str()这种操作，那说明代码还在用字符串指针，还是用pure C的风格在写代码
: 另外，sprintf()也是pure C的搞法，C++的搞法是std::format()或者fmt::format()，强调编译期的type-safe检查。
:
--
修改:ylh1969 FROM 114.244.128.*
FROM 114.244.128.*

补充一点，数据库操作，可以使用离散变量或struct。
但是离散变量，我没办法写出通用函数，所以必然要通过一个技术：
Struct Relational Mapping ,相当于JAVA的ORM。结构体与数据库表结构的对应。
另外，如果模板是自动生成，基本不用写列名。手动制作的，写一次就行了，到处用。
【 在 ylh1969 的大作中提到: 】
: 对于52楼的问题，你有何高招，解决一个泛型工具，完成一个通用的SQL操作，简单的，就来一个通用的insert吧。
: 能够提供的参数有：数据库句柄，表名，含有数据的数据结构，允许使用某种形式的模板。
: 我的形式如下：
: ...................
--
修改:ylh1969 FROM 114.244.128.*
FROM 114.244.128.*

pure C的我没兴趣搞了。

AI给的modern c++方式的：

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

// ---- 反射机制 ----
template<typename T>
struct Field {
    std::string_view name;
    T const* ptr;
};

#define REFLECTABLE(...) \
    static auto reflect_fields(const auto& self) { \
        return std::make_tuple(__VA_ARGS__); \
    }
#define FIELD(member) Field{#member, &self.member}

// ---- 用户结构体 ----
struct Employee {
    int id;
    double salary;
    std::string name;

    REFLECTABLE(
        FIELD(id),
        FIELD(salary),
        FIELD(name)
    )
};

// ---- SQL 生成 ----
template<typename T>
std::string SQL_insert(std::string_view table, const T& obj)
{
    auto fields = T::reflect_fields(obj);
    std::ostringstream sql;
    sql << "INSERT INTO " << table << " (";

    bool first = true;
    std::apply([&](auto&&... f) {
        ((sql << (first ? (first = false, "") : ",") << f.name), ...);
    }, fields);

    sql << ") VALUES (";
    first = true;
    std::apply([&](auto&&... f) {
        ((sql << (first ? (first = false, "") : ",") << ":" << f.name), ...);
    }, fields);

    sql << ")";
    return sql.str();
}

// ---- 调试输出 ----
template<typename T>
void SQL_bind_and_debug(const T& obj)
{
    auto fields = T::reflect_fields(obj);

    std::apply([&](auto&&... f) {
        (([&] {
            using FieldType = std::decay_t<decltype(*f.ptr)>;
            if constexpr (std::is_same_v<FieldType, int>)
                std::cout << "Bind int :" << f.name << " = " << *f.ptr << "\n";
            else if constexpr (std::is_same_v<FieldType, double>)
                std::cout << "Bind double :" << f.name << " = " << *f.ptr << "\n";
            else if constexpr (std::is_same_v<FieldType, std::string>)
                std::cout << "Bind string :" << f.name << " = '" << *f.ptr << "'\n";
        }()), ...);
    }, fields);
}

// ---- 测试 ----
int main()
{
    Employee e{1001, 55000.5, "Alice"};
    auto sql = SQL_insert("employee", e);

    std::cout << sql << "\n";
    SQL_bind_and_debug(e);
}



【 在 ylh1969 的大作中提到: 】
: 补充一点，数据库操作，可以使用离散变量或struct。
: 但是离散变量，我没办法写出通用函数，所以必然要通过一个技术：
: Struct Relational Mapping ,相当于JAVA的ORM。结构体与数据库表结构的对应。
: ...................
--
FROM 111.199.144.*

ok，我慢慢看。步骤差了许多，原理看看行不行。
看起来还是编译期泛型。
【 在 z16166 的大作中提到: 】
: pure C的我没兴趣搞了。
: AI给的modern c++方式的：
: #include <iostream>
: ...................
--
修改:ylh1969 FROM 114.244.128.*
FROM 114.244.128.*