free()：释放动态创建的类实例的 malloced 成员时出现无效指针错误，该实例本身是不同类的成员

Question

有一堂课WT.

它的一个成员wv_object被分配，当类的一个实例被创建

class WT 
{
    public:
        WT(int signalSize, int numLevels);
        ~WT();
        int signalSize_m;
        int numLevels_m;

    private:
        wv_object obj_m;
};

WT::WT(int signalSize, int numLevels)
    : signalSize_m(signalSize)
    , numLevels_m(numLevels)
{
    obj_m = wv_init();
}

WT::~WT()
{
    std::cout << "WT destructor called\n";
    free(obj_m);
    std::cout << "WT destructor ran without errors\n"; 
}

obj_m 基本上是一个结构对象。

typedef struct wv_set* wv_object;

struct wv_set
{
    int foo;
    int bar;
    double *foobar;
};

wv_object wv_init()
{
    int len = 20;
    wv_object obj = NULL;
    obj = (wv_object)malloc(sizeof(struct wv_set) + sizeof(double)* 4 * len);
    obj->foo = //something;
    obj->bar = //something;
    obj->foobar = //something
    return obj;
}

当我在某个函数中创建类 WT 的实例时，析构函数运行时没有任何错误。

int main() 
{
    WT* wt = new WT(100, 4);
    
    //
         "wt" is used for something
    //
    
    delete wt;
}

WT 析构函数调用

WT 析构函数运行无误

我有另一个类 AWT 有一个 WT 实例作为它的成员之一。

class AWT
{
    public:
        AWT(int signalSize, int numLevels, double alpha);
        ~AWT();
        signalSize_m;
        numLevels_m;
        // 
            other member variables and functions
        //

    private:
        WT* wt_m;
};

AWT::AWT(int signalSize, int numLevels, double alpha)
    : signalSize_m(signalSize)
    , numLevels_m(numLevels)
    , //Other members initialized 
{
    wt_m = new WT(signalSize, numLevels);
}

AWT::~AWT()
{
    std::cout << "AWT destructor called\n";
    delete wt_m;
    std::cout << "AWT destructor ran without errors\n";
}

当我在某个函数中创建类AWT的实例时

int main() 
{
    AWT* awt = new AWT(100, 4, 0.1);
    
    //
         "awt" is used for something
    //
    
    delete awt;
}

AWT 析构函数调用

WT 析构函数调用

free()：无效指针

调试器点告诉我错误发生在 WT 析构函数的 free(obj_m) 行。

当我在 AWT 析构函数中添加以下行时，我能够访问 obj_m 的内容，这意味着它尚未被销毁

AWT::~AWT()
{
    std::cout << "AWT destructor called\n";
    std::cout << wt_m->obj_m->foo << "\n";
    delete wt_m;
    std::cout << "AWT destructor ran without errors\n";
}

AWT 析构函数调用

100

WT 析构函数调用

free()：无效指针

我不知道为什么在第二种情况下 wt_m->obj_m 没有被释放，而在第一种情况下没有问题。如果我能得到任何关于如何解决这个问题的线索，我将不胜感激。