看代码：

class Base

{

public:

	Base()

	{

		cout<<"Base()"<<endl;

	}

	virtual ~Base()

	{

		cout<<"~Base()"<<endl;

	}

};

class Child:public Base

{

public:

	Child()

	{

		cout<<"Child()"<<endl;

	}

	virtual ~Child()

	{

		cout<<"~Child()"<<endl;

	}

};

int main(int argc, char* argv[])

{

	Child x;

	return 0;

}

子类对象被析构时，基类析构函数当然也会被调用。。。要不然基类里的东西怎么办？

你说的就是正确的，这个跟那个有什么关系么？

觉得不对就直接开贴反驳，不用顾忌什么专家不专家的...

看了下原贴。
这个和析构函数是不是虚函数没关系

子类对象被析构时，基类析构函数当然也会被调用。。。
这个是毋庸置疑的。

引用 2 楼 akirya 的回复:

你说的就是正确的，这个跟那个有什么关系么？

嗯，你说那样用是不对的，下面是你的代码：

#include<stdio.h>



class Base

{

    char sz[12];

public:

    virtual ~Base()

        {

            printf("Base::~Base\n");

        }

};



class test:public Base

{

    int data[4];

public:

    ~test()

        {

            printf("Base::~Base\n");

        }

};



int main()

{

    Base* p = new test[4];



    delete[] p;



    return 0;

}

这样自然是会输出8个的啊，因为派生类和基类都会调用

所以是可以用而且安全的啊

汗一个，是我搞错了，代码写错了。

还没看懂这个贴子想讨论什么。

就是啊，你把两个都写成了base。。。

汗。。。

引用 8 楼 dubiousway 的回复:

还没看懂这个贴子想讨论什么。

讨论的是，
“基类指针指向子类对象数组的问题 ”一贴里得出的结论是不对的。那贴说  基类指针指向子类对象数组  不可以使用

但实际上，基类指针指向子类对象数组 是可以使用的而且是安全的

而正是虚析构函数保证了这种安全性。

直接copy的代码，哎～～～
不过这样的代码不能在gcc和bc上用。
那两个输出的都是错误的。

引用 11 楼 akirya 的回复:

直接copy的代码，哎～～～ 
不过这样的代码不能在gcc和bc上用。 
那两个输出的都是错误的。

输出错误？

这代码在我这里怎么运行时错误？出错的行是int data[4];把它注释掉就正常了！

gcc 直接coredump 也就是所谓的非法操作
bc 输出了4次base::~base

坏，这段代码确实有问题！

你把最先的版本贴上来看看。我不关心你们的问题，我关心的是多态...

bc就算了。。可以不论

gcc不允许这样的话。。。意思是不鼓励这样写代码吧。。。

总之，设计角度讲确实不好，但是语言还是支持的

跟我的代码区别就是没有成员变量。

引用 13 楼 fetag 的回复:

这代码在我这里怎么运行时错误？出错的行是int data[4];把它注释掉就正常了！

哪来的int data[4]...眼神。。

引用 18 楼 paidfighting 的回复:

引用 13 楼 fetag 的回复:
这代码在我这里怎么运行时错误？出错的行是int data[4];把它注释掉就正常了！ 
 


哪来的int data[4]...眼神。。

哦，确实有，我这里运行没问题啊

OK，现在解决了。把最后那个delete应该改成

delete [] (test*)p;

才是正确的！

眼神...o(∩_∩)o...哈哈

确实有问题，原因如上，刚刚问了一个狂人...

引用 17 楼 akirya 的回复:

跟我的代码区别就是没有成员变量。

他说的是6楼，是copy你的

引用 20 楼 fetag 的回复:

OK，现在解决了。把最后那个delete应该改成 

delete [] (test*)p; 

才是正确的！

？怎么会，那虚析构函数还顶什么用。。。反正我这里不用加test*p也行的，vs2005

我测试的编译器
gcc 版本 4.1.3 20070929 (prerelease) (Ubuntu 4.1.2-16ubuntu2)
Borland C++ 5.5.1 for Win32 Copyright (c) 1993, 2000 Borland
Microsoft (R) 32-bit C/C++ Optimizing Compiler Version 14.00.50727.42 for 80x86

你的.NET 05这点上很差！

那样的代码是不正确的，最起码有三个主流编译器表现的结果相差太大了。

在那个帖子中我的理由错误了，但代码确实有问题。

引用 25 楼 fetag 的回复:

你的.NET 05这点上很差！

晕。。。。vc6也可以的

从语言特性来说

Base* p = new test[4];

new test[4]返回指针 test*，然后将其赋给p，这时候p因为虚函数表的存在，实际上是“保存”了对象类型的，即它知道指向的是test而不是Base，它并不会丢失类型信息。

所以delete[] p; 才能借助此机制成功析构对象

这应该说是vs好才对吧。。

遵守标准才是好，除非你的代码不考虑移植

BCB提供了一个很有用的扩展，能够将对象and成员函数赋值到一个指针上面，然后直接调用。
这样不少代码写起来更方便。
但移植的时候代码改的可就很大了。

下班走人了。。明天再来看了。。。大家先讨论~~

嘿嘿，楼上的，你想到混排的时候会怎么样了吗？

假如你的那个test[4]里面，有两个是Base的对象，有两个是test的对象，那你释放的时候用delete [] p;还能正常吗...

“基类指针指向子类对象数组不可以使用”这个结论是正确的。
这种行为是undefined.

比如在gcc上，当派生类（即子类）比基类占用更多的内存时，它明显将析构函数运行在了错误的内存上，从而导致程序崩溃。
而在vs2005上，只是因为编译器提供了更多的保护措施，以兼容这种错误，这并不意味者错误本身是正确的。
以下代码演示了vs2005的保护措施：

#include <iostream>

using namespace std;



class Base

{

public:

	Base()

	{

		cout<<"Base()"<<endl;

	}

	virtual ~Base()

	{

		cout<<"~Base()"<<endl;

	}

};

class Child:public Base

{

private:

	int* s_;       

public:

	Child()

	{

		s_ = new int[10];

		cout<<"Child()"<<endl;

	}

	 ~Child()

	{

		delete[] s_;

		cout<<"~Child()"<<endl;

	}

};



class Base2

{

public:

	Base2()

	{

		cout<<"Base2()"<<endl;

	}

	virtual ~Base2()

	{

		cout<<"~Base2()"<<endl;

	}

};

class Child2 : public Base2

{

public:

	Child2()

	{

		cout<<"Child2()"<<endl;

	}

	~Child2()

	{

		cout<<"~Child2()"<<endl;

	}

};



int main(int argc, char* argv[])

{

	Child2* c2 = reinterpret_cast<Child2*>(new Child[3]);

	delete [] c2;



	system("pause");

	return 0;

}

该代码的结果仍然是：
Base()
Child()
Base()
Child()
Base()
Child()
~Child()
~Base()
~Child()
~Base()
~Child()
~Base()
通过调试你会发现，s_所指向的数组被正确的释放了。
例中 vs2005 是按照 Child2 的方式寻找析构函数的，仍然找到了正确的结果。这说明，并非因为基类指针指向子类对象数组是正确的，而是 vs2005 的实现机制，恰好令其不发生错误。因此，无论Base*还是Child2*，在 vs2005 上都不出错了。
vs2005的机制是什么呢？首先是能够正确定位数组中的每个元素（用额外的内存直接或间接地记录元素长度信息）。其次是根据虚函数规则寻找合适的析构函数。请注意Child2继承自Base2，其虚函数表的形式恰好与Child（它继承自Base）一致，因此析构时以Child2的方式找到了~Child()。

又试了一下gcc，它能够正确地执行第一个析构函数，但是在执行第二个时崩溃了。
所以，gcc应该是在错误的位置上查找了第二个元素所对应的虚函数表。gcc和vs2005区别就在于按实际长度定位数组的元素上，gcc没有做，而vs2005做了（以占用更多空间为代价）。

引用 25 楼 fetag 的回复:

你的.NET 05这点上很差！

这种行为应该直接报错的，而不应该是编译器在背后做工作！

虽然VS 05能“兼容”这种错误的代码，但是这种方法确实不提倡。感觉微软在这一点上，又把程序员当傻瓜了...

卫亭出手果然不凡

try 
[code=C/C++]class base{
public:
    base()
    {
        cout<<"base construct"<<endl;
    }
    virtual ~base()
    {
        cout<<"base descontruct"<<endl;
    }
    virtual void test()
    {
        cout<<"base test"<<endl;
    }
};
class Child:public base
{
    int a;
public:
    Child()
    {
        cout<<"child construct"<<endl;
    }
    ~Child()
    {
        cout<<"child descontruct"<<endl;
    }
    void test()
    {
        cout<<"child test"<<endl;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    base* array = new Child[5];
   for( int i=0 ; i<5 ; i++ )
    {
        array[i].test(); 
    }

楼上的代码很好啊。即使在vs2005上，它也会报错，从而直接指明了问题所在。

在此处，vs2005在数组析构时所采用的保护策略没有起作用，一个显而易见的原因是效率（鉴于下标操作的频繁性）。

《More Effective C++》item3 不要对数组使用多态.
不知道是不是和你们讨论相关。

引用 36 楼 hdt 的回复:

try  
[code=C/C++]class base{ 
public: 
    base() 
    { 
        cout < <"base construct" < <endl; 
    } 
    virtual ~base() 
    { 
        cout < <"base descontruct" < <endl; 
    } 
    virtual void test() 
    { 
        cout < <"base test" < <endl; 
    } 
}; 
class Child:public base 
{ 
    int a; 
public: 
    Child() 
    { 
        cout < <"child construct" < <…

这个例子不足以推翻上面的说法

这里的array[i]访问，实际上是调用了operator[]()，而该函数应该就是按照指针类型来寻址的，它自然会错。c++为我们保证的是对象的构造和析构尽量正确，但它并没有保证运算符[]也可以随便用的。

我们讨论的只是析构时的问题，当然虽然我觉得是可以用的，但是它的确不是那么好，这也是事实。

引用 31 楼 Vitin 的回复:

“基类指针指向子类对象数组不可以使用”这个结论是正确的。 
这种行为是undefined. 

比如在gcc上，当派生类（即子类）比基类占用更多的内存时，它明显将析构函数运行在了错误的内存上，从而导致程序崩溃。 
而在vs2005上，只是因为编译器提供了更多的保护措施，以兼容这种错误，这并不意味者错误本身是正确的。 
以下代码演示了vs2005的保护措施： 

C/C++ code
#include <iostream>
using namespace std;

class B…

再看这一个例子。

我要说的是，在reinterpret_cast的使用规则上，Bjarne明确的说过，除非程序员知道自己在干什么，否则不要使用reinterpret_cast

你的这个例子是说明不了问题的。reinterpret_cast是一种程序员凌驾于c++的类型控制机制上的东西，超越它来做事，一切都控制在程序员手里

看例子：

class A{ 

	int* pA;

public: 

	A() 

	{ 

		pA = new int;

		cout <<"A construct" <<endl; 

	} 

	virtual ~A() 

	{ 

		cout <<"A descontruct" <<endl; 

		delete pA;

	} 

	virtual void test() 

	{ 

		cout <<"A test" <<endl; 

	} 

}; 

class B 

{ 

	double* pB; 

public: 

	B() 

	{ 

		pB = new double;

		cout <<"B construct" <<endl; 

	} 

	 ~B() 

	{ 

		cout <<"B descontruct" <<endl; 

		delete pB;

	} 

	void test() 

	{ 

		cout <<"B test" <<endl; 

	} 

}; 



int _tmain(int argc, _TCHAR* argv[]) 

{ 



	B* b = reinterpret_cast<B*>(new A);

	delete b;

}

这里照样会出错，归根结底，这是程序员的错而不是机制的错

然后再来看下面的例子：

class A{ 

	int* pA;

public: 

	A() 

	{ 

		pA = new int;

		cout <<"A construct" <<endl; 

	} 

	virtual ~A() 

	{ 

		cout <<"A descontruct" <<endl; 

		delete pA;

	} 

	virtual void test() 

	{ 

		cout <<"A test" <<endl; 

	} 

}; 

class B 

{ 

	double* pB; 

public: 

	B() 

	{ 

		pB = new double;

		cout <<"B construct" <<endl; 

	} 

	virtual ~B() 

	{ 

		cout <<"B descontruct" <<endl; 

		delete pB;

	} 

	void test() 

	{ 

		cout <<"B test" <<endl; 

	} 

}; 



int _tmain(int argc, _TCHAR* argv[]) 

{ 



	B* b = reinterpret_cast<B*>(new A);

	delete b;

}

注意，这里的代码和40楼代码的区别仅仅是B类析构函数多了个virtual，但是这里就成功析构了。

为什么？

多了个vitual实际上意味着B的对象里将含有一个虚函数表指针vfptr，这样说大家该明白了吧

A类的对象当然是含有vfptr的，40楼那里因为B类指针指向的内存将没有vfptr，所以类型信息丢失了，而这里类型信息被成功保存


所以，归根结底，并不是vs2005做的“好事”，而是虚函数表vfptr为我们提供了保证。


最后，“基类指针指向子类对象数组”这个题目可以总结为（我的观点）：

可以成功的应用于抽象类中，而且是安全的，同时，也只有抽象类才能为它提供保证。另外，它只能保证正确的析构，而不是支持指针的[]操作

这么喜欢讨论“后果自负”的代码？

引用 42 楼 taodm 的回复:

这么喜欢讨论“后果自负”的代码？

嗯，more effective c++上有：通过一个基类指针来删除一个含有派生类对象的数组，结果将是不确定的

没有意义了，不讨论了

这种方法不能用，一用数组就要错，so。。。。我认错 - -

引用 31 楼 Vitin 的回复:

引用 36 楼 hdt 的回复:

引用 38 楼 taodm 的回复:

《More Effective C++》item3 不要对数组使用多态. 
不知道是不是和你们讨论相关。

那么当需要一个数组来使用多态时,这样应是可行的.
Base* p[N] ;
for(int i=0;i<N;++i)
{
   if(i%2==0)
      p[i]=new Base();
   else
     p[i]=new Child();
}
//....
for(int i=0;i<N;++i)
{
   delete p[i];
}

虚函数表。。。

引用 44 楼 A_B_C_ABC 的回复:

引用 31 楼 Vitin 的回复:
 

引用 36 楼 hdt 的回复:

 

引用 38 楼 taodm 的回复:
《More Effective C++》item3 不要对数组使用多态.  
不知道是不是和你们讨论相关。 
 

那么当需要一个数组来使用多态时,这样应是可行的. 
Base* p[N] ; 
for(int i=0;i <N;++i) 
{ 
   if(i%2==0) 
      p[i]=new Base(); 
   else 
     p[i]=new Child(); 
} 
//.... 
for(int i=0;i <N;++i) 
{ 
   delete p[i]…

这是指针数组，和指向数组的指针不一样

reinterpret_cast，后果自负的运算符。

我知道不一样,但是一种变通,达到一样的效果.

引用 48 楼 A_B_C_ABC 的回复:

我知道不一样,但是一种变通,达到一样的效果.

嗯，re

请注意，31楼的代码不是为了证明这段代码是well-formed的，而是演示vs2005是如何析构数组的。它使用了reintepret_cast，并且能够正确运行，恰恰说明这种机制并不能用于否定“基类指针指向子类对象数组不可以使用”。因为，即使在语言明确不支持的地方，它也能正确运行。

所以，无论是虚函数表也好，vs2005支持的析构时数组元素定位也好，都只是一种实现机制。而语言（标准C++）并不限定实现机制。这就是说，一段代码能够在一种实现机制上正常运行并不意味着这段代码就是符合标准C++的。相反，如果它在某一种（符合标准C++的）实现机制上不能正确运行，那么往往意味着这段代码不符合标准C++。 当我们说“基类指针指向子类对象数组不可以使用”时，并不是指它在任何地方都一定会出错，而是它的行为属于undefined，它有可能出错，也可能不出错，这依赖于实现。

而36楼的代码，证明了即使在vs2005上，“基类指针指向子类对象数组不可以使用”也是正确的。难道，当你将基类指针指向子类对象数组，只是为了析构它吗？vs2005没有在数组下标操作中支持“基类指针指向子类对象数组”，恰恰说明即使在vs2005中，它也不是有意识地支持这一点，它在析构时，只是其实现机制“恰好”运行正常而已，这也是31楼的代码已经展示了的。

当然，如果你的代码只是为了在某个特定编译器上运行，并且你的代码只是用于特定的场景（如在vs2005上用于析构一个子类对象数组），那么你确实可以在研究了其实现机制后使用它。你确实知道这是一种undefined behavior，它不是标准C++，那么也就无可厚非了。