C++ 指针损坏？

Question

老实说，我不知道标题是否适合我遇到的问题。问题是这样的。我有一个名为 Engine 的类，其中有一个实例。

它包含两个成员变量(除其他外)称为 testTexture，我的自定义 Texture 类的实例，和 testObject，一个实例我的自定义对象类。

在引擎函数 Init 中，它们的值是这样设置的:

testTexture = Texture(0, TEXT("D:\\spriteWallVertical112.png"),
                      renderer.ReturnDevice());
testObject = Object(0,testTexture.textureID, D3DXVECTOR3(0,0,0),
                    D3DXVECTOR3(100,100,100), testTexture.texture, &renderer);

这一切似乎都按照我想要的方式运行，它们的值已存储并且看起来维护良好。

但是，在 Object 类构造函数中，调用了我的 Renderer 类中名为 AddNewTextureObject 的函数:

rendererPointer->AddNewTextureObject(&objectID, &textureID, textureInput, 
                                     &origin, &coordinates);

这看起来很顺利，但是当程序运行这些值时，指针似乎会随着程序的进行而被覆盖。它们不会立即变成垃圾内存，但很明显它们是。我可以根据需要提供代码，但我不想只用与问题无关的代码向这个问题发送垃圾邮件，尤其是当其他人可能发现我做错了一些明显的事情时。

不过，我现在会发布 TextureObject 类代码，因为我认为这是最相关的:

#ifndef TEXTUREOBJECT_H
#define TEXTUREOBJECT_H
#ifndef UNICODE
#define UNICODE
#endif

#include <d3dx9.h>

class TextureObject
{
public:
    TextureObject();
    TextureObject(unsigned int *, int *, LPDIRECT3DTEXTURE9, D3DXVECTOR3 *, D3DXVECTOR3 *);
    ~TextureObject();

    unsigned int *objectID; // The object with the texture.  Use this for locating and deleting this instance of TextureObject.
    int *textureID;
    LPDIRECT3DTEXTURE9 texture; // May not be needed if we can simply select the texture via ID.
    const D3DXVECTOR3 *origin; // Needed for drawing rotations....I think.
    D3DXVECTOR3 *coordinates;
    int maintainMe;
};
#endif

变量 maintainMe 在我赋值给它时会保留它的值。

这是 AddNewTextureObject() 函数的代码:

void Renderer::AddNewTextureObject(unsigned int *objectIDInput, int *textureIDInput, LPDIRECT3DTEXTURE9 textureInput, D3DXVECTOR3 *originInput, D3DXVECTOR3 *coordinatesInput)
{
    //testTextureObject = TextureObject(objectID, textureID, textureInput, originInput, coordinatesInput);
    testTextureObject.objectID = objectIDInput;
    testTextureObject.textureID = textureIDInput;
    testTextureObject.texture = textureInput;
    testTextureObject.origin = originInput;
    testTextureObject.coordinates = coordinatesInput;
    testTextureObject.maintainMe = 3067;

请注意，为 testTextureObject 赋值的任何一种方法都会导致问题。

如有任何帮助，我们将不胜感激。

编辑:

这是 Object 类的构造函数:

Object::Object(unsigned int objectIDInput, int textureIDInput, D3DXVECTOR3 originInput, D3DXVECTOR3 coordinatesInput, LPDIRECT3DTEXTURE9 textureInput, Renderer *rendererInput)
{
    objectID = objectIDInput;
    textureID = textureIDInput;
    origin = originInput;
    coordinates = coordinatesInput;
    rendererPointer = rendererInput;
    rendererPointer->AddNewTextureObject(&objectID, &textureID, textureInput, &origin, &coordinates);
}

它在 Object 类的 Object.h 中声明为 public，如下所示:

Object(unsigned int, int, D3DXVECTOR3, D3DXVECTOR3, LPDIRECT3DTEXTURE9, Renderer *);

EDIT2:我创建了一个复制构造函数和一个赋值运算符:

Object::Object(const Object &source)
{
    objectID = source.objectID;
    textureID = source.textureID;
    texture = source.texture;
    origin = source.origin;
    coordinates = source.coordinates;
    rendererPointer = source.rendererPointer;
}

Object& Object::operator=(const Object &source)
{
    if(this == &source)
    {
        return *this;
    }

    objectID = source.objectID;
    textureID = source.textureID;
    texture = source.texture;
    origin = source.origin;
    coordinates = source.coordinates;
    rendererPointer = source.rendererPointer;

    return *this;
}

在你们更有经验的人看来，这些看起来正确吗？不幸的是，仅此一项似乎并不能解决问题。

Answer 1

由于您定义了析构函数，并且您的 TextureObject 类中有指针，因此您需要遵循规则 3:定义析构函数、复制构造函数和赋值运算符。看起来指针可能源自 Object，因此您可能也需要对该类执行相同的操作。

我想您面临的问题是悬空指针问题，因为在您初始化 testObject 之后，用于初始化它的临时对象会析构，并释放在其中初始化的指针。因此，testTextureObject 现在持有指向已释放内存的指针(因为这些指针最初来自临时内存)。

编辑:根据 Object 的构造函数，我们看到 rendererPointer->AddNewTextureObject 正在从当前 传递指针Object 实例，这将是临时实例。

testObject = Object(0,testTexture.textureID, D3DXVECTOR3(0,0,0),
                    D3DXVECTOR3(100,100,100), testTexture.texture, &renderer);

这行代码创建了一个Object的临时实例，然后使用赋值运算符来初始化testObject。在这行代码之后，临时文件将被破坏。现在 renderer 持有一个 TextureObject，它被初始化为来自一个不再存在的临时指针。

编辑:您似乎对 3 法则试图帮助您解决的问题有些困惑。您可以阅读 the accepted answer关于规则 3 的问题。但是给你一个简单的例子，只考虑分配内存的类的简单问题。

class Foo {
    Bar *bar;
public:
    Foo () : bar(new Bar) {}
    ~Foo () { delete bar; }
    Bar * get_bar () { return bar; }
};

要求析构函数不泄漏内存。但是，如果使用复制构造函数或赋值运算符，则会引入一些问题。

Foo a;
Foo b(a); // copy

b 的问题在于它持有与a 相同的指针。所以当b和a被析构时，指针会被删除两次。

Foo a;
Foo c;
c = a;    // assign

c 的问题在于它不仅持有与 a 相同的指针(这将导致双重删除)，而且它在其构造函数中创建的任何内存现在已经泄露了。

规则 3 是:如果需要析构函数，那么也需要复制构造函数和赋值运算符。该规则的目的是让开发人员思考需要通过添加析构函数来解决的问题，以及这些问题对复制构造和赋值有什么影响，并制定合理的解决方案。

在您的例子中，renderer 持有一个由临时 Object 创建的 TextureObject。您需要考虑如何解决这种情况，要么在 Object 的析构函数、复制构造函数和赋值运算符中，要么通过使用其他解决方案避免问题。