高手帮我看看, 析够函数为什么不能够正常调用?
Class Object
{
public:
virtual Object(){std::cout<<"Object Created\n";};
}

Class TestA:Object
{
public:
TestA(){std::cout<<"TestA Created\n";};
~TestA(){std::cout<<"Destory TestA\n"};
}


Class TestB:Object
{
public:
TestB()
{
std::cout<<"TestB Created\n";
p = new int;
};
~TestB()
{
std::cout<<"Destory TestB\n"
delete p;
};
private:
int *p;
}

Class TestC
{
public:
TestC()
{
std::cout<<"TestC Created\n";
p = new int;
};
~TestC()
{
std::cout<<"Destory TestC\n"
delete p;
};
private:
int *p;
}


test1()
{
void *pTest = new TestB;
delete (TestA*)pTest;
}

test2()
{
void *pTest = new TestB;
delete (TestC*)pTest;
}

test3()
{
void *pTest = new TestB;
delete pTest;
}

void main()
{
test1();
test2();
test3();
}

请问这3个函数中 哪些会引起内存泄漏？ 为什么？


[解决办法]

C/C++ code

#include <iostream.h>class object  {  public:    virtual ~object(){};  }; class testa:public object  {  public:    testa()    {        cout<<"testa created\n";    }     ~testa()    {        cout<<"destory testa\n";    }  };  class testb:object  {  public:    testb()      {        cout<<"testb created\n";          p = new int;      };        ~testb()      {        cout<<"destory testb\n";          delete p;      };  private:      int *p;  };  class testc  {  public:    testc()    {        cout<<"testc created\n";        p = new int;    }    ~testc()      {          cout<<"destory testc\n";        delete p;      };  private:      int *p;  };  void test1()  {     void *ptest = new testb;      delete (testa*)ptest;  //1）先调用了~testb(),之后调用了~object}  void test2()  {      void *ptest = new testb;      delete (testc*)ptest;  //2）调用了~testc()，在执行其中的delete p; 语句时崩溃！}  void test3()  {    void *ptest = new testb;    delete ptest; // 3）没有调用析构函数 testb::~testb()}  void main()  {    test1();      test2();      test3();  }
[解决办法]
谁来答案？ 偶关注了一天了
[解决办法]
第三个明显有内存泄露,因为不会调用析构,为啥不调析构呢?因为delete掉的是个void*,编译器不知道调谁的析构.
[解决办法]
#include<iostream>
class Object 
{ 
public: 
virtual ~Object(){}; 
} ;  

class TestA:Object 
{ 
public: 
TestA(){std::cout<<"TestA Created\n";} 
~TestA(){std::cout  <<"Destory TestA\n";} 
} ;  


class TestB:Object 
{ 
public: 
TestB() 
{ 
std::cout  <<"TestB Created\n"; 
p = new int; 
}; 
~TestB() 
{ 
std::cout  <<"Destory TestB\n"  ;
delete p; 
}; 
private: 
int *p; 
} ;  

class TestC://Object  
{ 
public: 
TestC() 
{ 
std::cout  <<"TestC Created\n"; 
p = new int; 
}; 
~TestC() 
{ 
std::cout  <<"Destory TestC\n"; 
delete p; 
}  
private: 
int *p; 
}  ;


void test1() 
{ 
void *pTest = new TestB; 
delete (TestA*)pTest;  
 
} 

void test2() 
{ 
void *pTest = new TestB; 
delete (TestC*)pTest; 
} 

void test3() 
{ 
void *pTest = new TestB; 
delete /*(TestB*)*/pTest; 
} 

void main() 
{ 
test1();  ／／此处不会发生内存泄露，因为Object的析构函数是虚函数，而A,B继承至Object，所以是动态绑定
        //调用的是B的析构函数
test2();  //此处会崩溃，因为C不是继承至Object，所以会掉用Ｃ的析构函数，释放未分配的内存，所以崩溃
test3();  ／／此处会泄露,原理和上面一样，分配的内存未释放，也没有动态绑定，所以不会调用Ｂ的析构函数
} 
这个是改后的程序，呵呵