就是“无脑”。跟无脑用递归锁是一样的。

但归根结底，是因为没有“规则”和惩罚，只靠个人品味。
--
修改:z16166 FROM 123.115.134.*
FROM 123.115.134.*

unique_ptr的申请和释放是可以在同一个scope内的呀

【 在 foliver 的大作中提到: 】
: 本质上都是因为申请和释放不在一起导致的。
:
--
FROM 123.115.134.*

就事论事，不用说太远，哈哈

【 在 tortelee 的大作中提到: 】
: 你这么说， listener设计模式，都可以用sharedptr代替了
:
: :
--
FROM 111.199.144.*

这可不是语言的问题，而是这个level的语言（靠近机器的无GC的语言）都要面临这个问题。
比如Rust有Box<T>、Rc<T>、Arc<T>。

也就是说，如果你不需要区分unique_ptr和shared_ptr，那么你实际上很可能可以换用别的语言来实现你的需求，比如js或者py，这样就不用关心这个level的问题。

再一个，unique_ptr和shared_ptr不属于语法范畴，只是库。

【 在 iamiiami 的大作中提到: 】
: 如果少数人这样是人的问题。如果很多人这样用，那就是语言的问题了。c++不在基础库上发力，语法发展得都快读不懂了。
--
修改:z16166 FROM 111.199.144.*
FROM 111.199.144.*

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.*