含结构体的Model类析构函数问题求助

Hey there! Let's work through fixing that memory leak issue with your Model class destructor for your OpenGL assignment. I’ve been in this exact spot before—forgetting to clean up both CPU memory and GPU resources, or tripping over shallow copies, can make your program crash when you add a destructor. Here’s how to tackle it step by step:

1. First, Clean Up All CPU-Side Heap Allocations #

Your Model class has pointers to structs (like Mesh* or Texture*) allocated with new/new[]. In your destructor, you need to:

• Delete each individual struct instance first (since they’re allocated with new), then delete the array of pointers (allocated with new[]).
• Add null checks to avoid crashes if pointers were never initialized.

Example destructor code for your Model class:

~Model() {
    // Clean up meshes
    if (meshes != nullptr) {
        for (size_t i = 0; i < meshCount; ++i) {
            delete meshes[i]; // Delete each Mesh instance
        }
        delete[] meshes; // Delete the array of pointers
        meshes = nullptr; // Optional: Mark as null to avoid wild pointers
    }

    // Repeat the same pattern for textures, materials, or other heap-allocated members
    if (textures != nullptr) {
        for (size_t i = 0; i < textureCount; ++i) {
            delete textures[i];
        }
        delete[] textures;
        textures = nullptr;
    }
}

2. Don’t Forget OpenGL GPU Resources! #

OpenGL objects like VAOs, VBOs, EBOs, and texture IDs live on the GPU—you can’t delete them with delete. Use OpenGL’s cleanup functions inside your child structs’ destructors.

For example, if your Mesh struct holds OpenGL buffer IDs:

struct Mesh {
    unsigned int vao, vbo, ebo;
    std::vector<Vertex> vertices;
    // ... other members

    ~Mesh() {
        // Clean up GPU resources
        glDeleteVertexArrays(1, &vao);
        glDeleteBuffers(1, &vbo);
        glDeleteBuffers(1, &ebo);
    }
};

Same goes for textures—add glDeleteTextures(1, &textureID); to your Texture struct’s destructor.

3. Fix Shallow Copy Issues (The Silent Crash Culprit) #

If you’re copying Model objects anywhere (passing by value, assigning, etc.), the default copy constructor/assignment operator will just copy pointers—leading to double free errors when both objects try to delete the same memory.

You have two options:

Option A: Disable Copying (If You Don’t Need Copyable Models)

Add these lines to your Model class definition:

// Disable copy constructor and assignment operator
Model(const Model&) = delete;
Model& operator=(const Model&) = delete;

Option B: Implement Deep Copy (If You Need Copyable Models)

If you do need to copy Model instances, write custom copy logic that reallocates memory and copies actual data (not just pointers):

// Copy constructor
Model(const Model& other) : meshCount(other.meshCount), textureCount(other.textureCount) {
    // Allocate new array for meshes
    meshes = new Mesh*[meshCount];
    for (size_t i = 0; i < meshCount; ++i) {
        meshes[i] = new Mesh(*other.meshes[i]); // Assumes Mesh has a copy constructor
    }

    // Do the same for textures
    textures = new Texture*[textureCount];
    for (size_t i = 0; i < textureCount; ++i) {
        textures[i] = new Texture(*other.textures[i]);
    }
}

// Assignment operator
Model& operator=(const Model& other) {
    if (this != &other) { // Avoid self-assignment
        // First clean up existing resources
        if (meshes != nullptr) {
            for (size_t i = 0; i < meshCount; ++i) {
                delete meshes[i];
            }
            delete[] meshes;
        }
        if (textures != nullptr) {
            for (size_t i = 0; i < textureCount; ++i) {
                delete textures[i];
            }
            delete[] textures;
        }

        // Now copy the new data
        meshCount = other.meshCount;
        textureCount = other.textureCount;

        meshes = new Mesh*[meshCount];
        for (size_t i = 0; i < meshCount; ++i) {
            meshes[i] = new Mesh(*other.meshes[i]);
        }

        textures = new Texture*[textureCount];
        for (size_t i = 0; i < textureCount; ++i) {
            textures[i] = new Texture(*other.textures[i]);
        }
    }
    return *this;
}

4. Debug with Memory Tools to Verify Fixes #

To confirm you’ve plugged all leaks:

• On Linux/macOS: Use valgrind ./your-program to get a detailed leak report.
• On Windows: Use Visual Studio’s built-in Memory Leak Detector—add #define _CRTDBG_MAP_ALLOC at the top of your main file, then call _CrtDumpMemoryLeaks(); right before main() exits.

These tools will point out exactly which memory blocks aren’t being freed, so you can spot any missed cleanup.

内容的提问来源于stack exchange，提问作者J. Doe