如何让非POD对象默认初始化至同一固定地址且后续可修改？

你的核心需求是让未填充的对象共享固定的Null实例地址，同时在赋值后拥有独立的可修改内存。由于栈上局部对象的内存地址无法强制相同，我们可以通过代理类+延迟分配的方式，让未填充对象的数据指向全局Null实例，赋值后再分配独立内存，完美匹配你的序列化与内存优化需求。

修改后的完整代码 #

// 原数据载体结构，保持简洁
struct foo{
    int objdata;
    
    explicit foo(int val = 0) : objdata(val) {}

    friend std::ostream &operator<<(std::ostream &, const foo &);
};

// 全局固定的Null实例
const foo NullFoo;

std::ostream &operator<<(std::ostream &os, const foo &f){
    os << f.objdata << '\t' << &f;
    return os;
}

// 代理类：实现空对象共享与延迟分配
class FooProxy {
private:
    const foo* data_ptr; // 默认指向NullFoo，赋值后指向自有内存
    std::unique_ptr<foo> owned_data; // 仅在赋值时分配的自有内存

public:
    // 默认构造：绑定到全局NullFoo
    FooProxy() : data_ptr(&NullFoo) {
        std::clog << "\033[48;2;100;150;100mcreated\t" << *this << "\033[m\n";
    }

    // 拷贝构造：源为Null则共享，否则拷贝数据
    FooProxy(const FooProxy& other) {
        if (other.owned_data) {
            owned_data = std::make_unique<foo>(*other.owned_data);
            data_ptr = owned_data.get();
        } else {
            data_ptr = &NullFoo;
        }
        std::clog << "\033[48;2;100;150;100mcopied\t" << *this << "\033[m\n";
    }

    // 移动构造
    FooProxy(FooProxy&& other) noexcept 
        : data_ptr(other.data_ptr), owned_data(std::move(other.owned_data)) {
        other.data_ptr = &NullFoo;
        std::clog << "\033[48;2;100;150;100mcopied\t" << *this << "\033[m\n";
        std::clog << "\033[48;2;100;150;150mreseted\t" << other << "\033[m\n";
    }

    ~FooProxy() {
        std::clog << "\033[48;2;150;100;100mdeleted\t" << *this << "\033[m\n";
    }

    // 赋值int：分配自有内存并存储值
    FooProxy& operator=(int value) {
        if (!owned_data) {
            owned_data = std::make_unique<foo>();
        }
        owned_data->objdata = value;
        data_ptr = owned_data.get();
        std::clog << "\033[48;2;100;130;100massigned\t" << *this << "\033[m\n";
        return *this;
    }

    // 拷贝赋值
    FooProxy& operator=(const FooProxy& other) {
        if (this != &other) {
            if (other.owned_data) {
                owned_data = std::make_unique<foo>(*other.owned_data);
                data_ptr = owned_data.get();
            } else {
                owned_data.reset();
                data_ptr = &NullFoo;
            }
            std::clog << "\033[48;2;100;130;120mcopy assigned\t" << *this << "\033[m\n";
        }
        return *this;
    }

    // 移动赋值
    FooProxy& operator=(FooProxy&& other) noexcept {
        if (this != &other) {
            owned_data = std::move(other.owned_data);
            data_ptr = other.data_ptr;
            other.data_ptr = &NullFoo;
            std::clog << "\033[48;2;100;130;120mcopy assigned\t" << *this << "\033[m\n";
            std::clog << "\033[48;2;100;150;150mreseted\t" << other << "\033[m\n";
        }
        return *this;
    }

    // 重载解引用，保持与原foo的接口一致性
    const foo& operator*() const { return *data_ptr; }
    foo& operator*() { 
        // 修改前自动分配自有内存（如果当前是Null状态）
        if (!owned_data) {
            owned_data = std::make_unique<foo>(*data_ptr);
            data_ptr = owned_data.get();
        }
        return *data_ptr; 
    }

    // 重载箭头运算符
    const foo* operator->() const { return data_ptr; }
    foo* operator->() { 
        if (!owned_data) {
            owned_data = std::make_unique<foo>(*data_ptr);
            data_ptr = owned_data.get();
        }
        return data_ptr; 
    }

    // 输出函数：打印数据值、数据地址、NullFoo地址
    friend std::ostream& operator<<(std::ostream& os, const FooProxy& fp) {
        os << fp.data_ptr->objdata << '\t' << fp.data_ptr << '\t' << &NullFoo;
        return os;
    }
};

// 测试入口
int main(){
    { // 作用域控制对象生命周期，方便查看日志
    std::cout << NullFoo << "\t" << &NullFoo << std::endl;
    FooProxy a;
    std::cout << a << std::endl;
    a = rand()%0x100;
    std::cout << a << std::endl;
    FooProxy b;
    std::cout << b << std::endl;
    b = a;
    std::cout << b << std::endl;
    }

    return 0;
}

核心逻辑说明 #

1. 空对象共享：所有未赋值的FooProxy实例默认指向全局NullFoo，此时它们的数据地址完全一致，满足序列化时识别Null状态的需求，且无需为每个未填充对象分配独立内存。
2. 延迟分配：当执行赋值操作（包括赋值int、拷贝/移动其他实例）时，代理类才会通过std::unique_ptr分配自有内存，将数据指针切换到自有内存区域，此时实例拥有独立的可修改数据。
3. 接口兼容：通过重载operator*和operator->，FooProxy可以像原foo结构体一样被使用，无需修改原有业务代码的调用逻辑。

预期运行输出 #

0	0x5600e97b13ec	0x5600e97b13ec
created	0	0x5600e97b13ec	0x5600e97b13ec
0	0x5600e97b13ec	0x5600e97b13ec
assigned	103	0x5600e97b1400	0x5600e97b13ec
103	0x5600e97b1400	0x5600e97b13ec
created	0	0x5600e97b13ec	0x5600e97b13ec
0	0x5600e97b13ec	0x5600e97b13ec
copy assigned	103	0x5600e97b1420	0x5600e97b13ec
103	0x5600e97b1420	0x5600e97b13ec
deleted	103	0x5600e97b1420	0x5600e97b13ec
deleted	103	0x5600e97b1400	0x5600e97b13ec
deleted	0	0x5600e97b13ec	0x5600e97b13ec

从输出可见：

• 未赋值的实例数据地址与NullFoo完全相同
• 赋值后的实例拥有独立内存地址，且可正常修改数据
• 完美实现了“未填充时共享固定地址、填充后独立可修改”的需求

内容的提问来源于stack exchange，提问作者Danilo