C++管理类指针队列时vector成员丢失问题求助

你遇到的问题核心是栈上局部对象的生命周期不匹配，咱们一步步拆解来看：

在你的while循环内部，another_aclass_object是个栈分配的局部变量——它的生命周期只限于当前这一次循环迭代。当循环执行到末尾，这个对象就会被销毁，它占用的内存会被系统回收或重新利用。但你把它的地址&another_aclass_object推入了队列，当下一次循环取出这个指针时，它指向的是已经“不存在”的对象，这属于C++里的未定义行为。

为什么int成员看似正常？这只是巧合——栈内存释放后，原来的数值可能暂时没被新数据覆盖，但这完全不可靠；而vector的内部结构（比如指向堆内存的指针）已经被破坏，所以读取它的size或者元素时就会失效。

问题代码关键片段 #

while (!aclass_pointers_queue.empty()) {
    // ... 其他逻辑
    AClass another_aclass_object; // 仅在本次循环迭代存活的栈对象
    another_aclass_object.a_number = 3;
    another_aclass_object.a_vector = { 5,4,3,2,1 };
    aclass_pointers_queue.push(&another_aclass_object); // 推入即将失效的指针
    // ... 其他逻辑
}

解决方案 #

根据你的场景需求，这里有几种靠谱的解决方式：

方案1：用动态分配对象（堆内存） #

如果必须用指针，就用new在堆上创建对象，这样对象的生命周期由你手动控制，直到调用delete释放：

while (!aclass_pointers_queue.empty()) {
    AClass* current_class_object = aclass_pointers_queue.front();
    current_class_object->print();
    aclass_pointers_queue.pop();
    
    // 在堆上创建对象
    AClass* another_aclass_object = new AClass();
    another_aclass_object->a_number = 3;
    another_aclass_object->a_vector = { 5,4,3,2,1 };
    aclass_pointers_queue.push(another_aclass_object);
    
    if (some_break_condition >= 2) {
        break;
    }
    some_break_condition++;
}

// 最后记得清理队列里剩余的堆对象，避免内存泄漏
while (!aclass_pointers_queue.empty()) {
    delete aclass_pointers_queue.front();
    aclass_pointers_queue.pop();
}

方案2：用智能指针（更安全，自动管理内存） #

手动管理new/delete容易遗漏导致内存泄漏，推荐用std::unique_ptr自动管理对象生命周期：

#include <memory> // 需包含智能指针头文件

int main() {
    std::queue<std::unique_ptr<AClass>> aclass_pointers_queue;
    
    // 初始化第一个对象
    auto first_obj = std::make_unique<AClass>();
    first_obj->a_number = 2;
    first_obj->a_vector = { 1,2,3,4,5 };
    aclass_pointers_queue.push(std::move(first_obj));
    
    int some_break_condition = 1;
    while (!aclass_pointers_queue.empty()) {
        auto current_obj = std::move(aclass_pointers_queue.front());
        current_obj->print();
        aclass_pointers_queue.pop();
        
        // 创建新的智能指针对象
        auto another_obj = std::make_unique<AClass>();
        another_obj->a_number = 3;
        another_obj->a_vector = { 5,4,3,2,1 };
        aclass_pointers_queue.push(std::move(another_obj));
        
        if (some_break_condition >= 2) {
            break;
        }
        some_break_condition++;
    }
    // 无需手动delete，智能指针会自动清理内存
    return 0;
}

方案3：直接存储对象而非指针（场景允许时优先选） #

如果你的对象复制成本不高，直接在队列里存储AClass对象，完全规避指针生命周期问题：

int main() {
    std::queue<AClass> aclass_queue;
    
    AClass first_aclass_object;
    first_aclass_object.a_number = 2;
    first_aclass_object.a_vector = { 1,2,3,4,5 };
    aclass_queue.push(first_aclass_object);
    
    int some_break_condition = 1;
    while (!aclass_queue.empty()) {
        AClass current_obj = aclass_queue.front();
        current_obj.print();
        aclass_queue.pop();
        
        AClass another_obj;
        another_obj.a_number = 3;
        another_obj.a_vector = { 5,4,3,2,1 };
        aclass_queue.push(another_obj);
        
        if (some_break_condition >= 2) {
            break;
        }
        some_break_condition++;
    }
    
    return 0;
}

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