C++中向小对象传递原始指针的正确方式及double free问题排查

错误原因：栈内存被错误地delete #

咱们先聚焦代码里的核心问题点——看你的main函数：

World world{ 4, 6, "stuff" };
A a(&world);

这里的world是栈上分配的对象，它的生命周期由编译器自动管理：当main执行完毕时，栈会自动清理这个对象。但你的A类析构函数里写了delete world_;，这就触发了未定义行为——delete只能用来释放堆上通过new分配的内存，对栈对象调用delete相当于重复释放内存，直接导致了你看到的double free or corruption错误。

你提到移除析构函数后错误消失，这完全合理：此时A不会去尝试释放它不拥有的内存，栈对象world会在main结束时正常自动销毁，没有重复释放的问题。你之前的误解在于：只有当你的对象真正拥有指针指向的内存（即由该对象负责用new分配这块内存）时，才需要在析构函数里用delete清理。在这个场景里，A只是持有指针，并没有分配world的内存，自然不该去delete它。

更优实现方案 #

针对你的需求（A持有资源指针，传给B临时使用，B销毁后A继续使用该资源），推荐以下几种方案：

方案1：明确所有权，移除错误的delete #

如果A不拥有world的所有权（比如world是栈对象，或由其他模块管理），直接去掉A析构函数里的delete即可。同时为了避免浅拷贝带来的潜在风险（比如多个A对象指向同一个堆对象，被误释放），可以禁用拷贝/移动操作：

修改后的A类：

class A {
private:
    World *world_;
public:
    explicit A(World *world) : world_(world) {}
    ~A() { /* 移除delete，因为不拥有所有权 */ }
    
    // 禁用拷贝/移动，避免多实例指向同一资源的风险（可选）
    A(const A &a) = delete;
    A(A &&a) noexcept = delete;
    A &operator=(const A &a) = delete;
    A &operator=(A &&a) noexcept = delete;
    
    std::string doCleverStuff(){
        B b(world_);
        return b.doSomethingCleverWithWorld();
    }
};

方案2：用智能指针明确所有权管理 #

如果world是堆对象，推荐用C++标准库的智能指针彻底解决内存管理问题：

• 若A是world的唯一所有者，用std::unique_ptr，B临时访问时传原始指针即可：

class A {
private:
    std::unique_ptr<World> world_;
public:
    explicit A(std::unique_ptr<World> world) : world_(std::move(world)) {}
    
    // 无需手动写析构，unique_ptr会自动释放内存
    
    std::string doCleverStuff(){
        B b(world_.get());
        return b.doSomethingCleverWithWorld();
    }
};

// main函数调用示例
int main() {
    auto world = std::make_unique<World>(World{4, 6, "stuff"});
    A a(std::move(world));
    std::string clever = a.doCleverStuff();
    std::cout << clever << std::endl;
    return 0;
}

• 若需要多个对象共享world所有权，用std::shared_ptr，所有持有者销毁后资源才会释放：

class B {
private:
    std::shared_ptr<World> world_;
public:
    std::string doSomethingCleverWithWorld(){
        std::ostringstream os;
        os << world_->c << " = " << world_->a + world_->b <<std::endl;
        return os.str();
    }
    explicit B(std::shared_ptr<World> world) : world_(world) {}
};

class A {
private:
    std::shared_ptr<World> world_;
public:
    explicit A(std::shared_ptr<World> world) : world_(world) {}
    
    std::string doCleverStuff(){
        B b(world_);
        return b.doSomethingCleverWithWorld();
    }
};

// main函数调用示例
int main() {
    auto world = std::make_shared<World>(World{4, 6, "stuff"});
    A a(world);
    std::string clever = a.doCleverStuff();
    std::cout << clever << std::endl;
    return 0;
}

方案3：直接传递引用（最安全的场景化方案） #

如果world的生命周期肯定长于B和A，完全可以不用指针，直接用引用，避免空指针风险：

修改B和A类：

class B {
private:
    const World &world_; // 用const引用表明仅读取资源
public:
    std::string doSomethingCleverWithWorld(){
        std::ostringstream os;
        os << world_.c << " = " << world_.a + world_.b <<std::endl;
        return os.str();
    }
    explicit B(const World &world) : world_(world) {}
};

class A {
private:
    const World &world_;
public:
    explicit A(const World &world) : world_(world) {}
    
    std::string doCleverStuff(){
        B b(world_);
        return b.doSomethingCleverWithWorld();
    }
};

// main函数无需修改
int main() {
    World world{ 4, 6, "stuff" };
    A a(world);
    std::string clever = a.doCleverStuff();
    std::cout << clever << std::endl;
    return 0;
}

这种方式最安全，引用不能为空，且无需手动管理内存，编译器会自动处理生命周期。

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