请教一道c++题目

[xfxf20]

#include <iostream>

using namespace std;
class A
{
public :
A(int i = 0)
{
m_i = i;
cout << m_i <<endl;
cout<< "A::A()" << endl;
}
~A(){ cout << m_i <<endl<< "A::~A()\n";}
void f(){cout << m_i <<endl<< "A::f()\n";}

private:
int m_i;
};

class B:public A
{
public:
A m_A;

B(int i):m_A(i)
{
cout << "B::B()\n";
}
~B(){cout << "B::~B()\n";}

void f(){cout << "B::f()\n";}
};
int main( void )
{
A *pa = new B(10);
pa->f();
delete pa;
}

写出上述代码的输出，并说明原因。

[wwwypy]

我运行了一下，但是我不明白为啥不调用B的析构函数呢？？？等高手来解决。

[daidodo]

只有当A的析够函数是virtual时，通过delete pa调用的才是B的析够函数。

[帅得不敢出门]

gcc
0
A::A()
10
A::A()
B::B()
0
A::f()
0
A::~A()
-------------
//A *pa = new B(10);
类数据成员先构造
0
A::A()
构造基类部分
10 A::A()
派生类构造函数B::B()
//pa->f();
调用A::f()
0
A::f()
//delete pa;
由于不是虚析构函数 所以调用~A()

[--小智--]

是啊，这里A的析购函数和成员函数f（）都没有声明为virtual，所以不会发生动态绑定，因为pa的静态类型为A，所以只会调用A的函数。
所以一般基类的析构函数应该声明为virtual，否则可能会出现局部销毁，
最先构造基类部分，所以A的构造函数被调用，然后是子对象，基类没有传参数，所以，缺省值为0，子对象构造时值为10

[e_sharp]

virtual ~A(){ cout < < m_i < <endl < < "A::~A()\n";}

[matrixcl]

#include <iostream> 

using namespace std; 
class A 
{ 
public : 
	A(int i = 0) 
	{ 
		m_i = i; 
		cout << m_i <<endl; 
		cout << "A::A()" << endl; 
	} 
	~A(){ cout << m_i <<endl << "A::~A()\n";} 
	void f(){cout << m_i <<endl << "A::f()\n";} 

private: 
	int m_i; 
}; 

class B:public A 
{ 
public: 
	A m_A; 

	B(int i):m_A(i) 
	{ 
		cout << "B::B()\n"; 
	} 
	~B(){cout << "B::~B()\n";} 

	void f(){cout << "B::f()\n";} 
}; 
int main( void ) 
{ 
	//调用B的构造函数，因为B的基类是A，所以
	//1.先调A的构造函数，
	//2.初始化B的成员变量m_A  (B(int i):m_A(i) 冒号后面的部分)
	//3.然后才调B的构造函数。
	//但是A的构造函数是隐式调用,未传参数,使用默认参数0
	//输出：
	// 0
	// A::A()
	// 10
	// A::A()
	// B::B()
	A *pa = new B(10);

	//执行A::f() (因为A::f()不是虚函数)
	//输出：
	// 0
	// A::f()
	pa->f(); 

	//执行A::~A() (因为A::~A()不是虚函数)
	//输出：
	// 0
	// A::~A()
	delete pa; 
} 

[shuangbi]

6楼的讲的很清楚，学习了

[帅得不敢出门]

修正下gcc 下测试输出
0
A::A()
10
A::A()
B::B()
0
A::f()
0
A::~A()
-------------
//A *pa = new B(10);
构造基类部分
0
A::A()
-----------
类数据成员m_A
10
A::A()
------
派生类构造函数B::B()
//pa->f();
调用A::f()
0
A::f()
------------
//delete pa;
由于不是虚析构函数 所以调用~A()

[kingofice]

基类的析构函数是虚函数时，其派生类的析构函数才会在调用了自己之后调用积累的析构函数。
一般来说，只要类有可能被继承，其析构函数就最好写成虚拟的，否则可能出现资源泄漏之类的问题。

[xiaodongdehome]

[Quote=引用 9 楼 kingofice 的回复:]
基类的析构函数是虚函数时，其派生类的析构函数才会在调用了自己之后调用积累的析构函数。
一般来说，只要类有可能被继承，其析构函数就最好写成虚拟的，否则可能出现资源泄漏之类的问题。
[/Quote]
赞同!

[libing035]

学习了.

[jackylea]

[Quote=引用 6 楼 matrixcl 的回复:]
C/C++ code

#include <iostream>

using namespace std;
class A
{
public :
A(int i = 0)
{
m_i = i;
cout << m_i <<endl;
cout << "A::A()" << endl;
}
~A(){ cout << m_i <<endl << "A::~A()\n";}
void f(){cout << m_i <<endl << "A::f()\n";}

private:
int m_i;
};

class B:public A
{
public:
A m_A;

B(int i…
[/Quote]
好！！！

[zjfhgdx]

前面的很简单只是后面

new了一个B类,
当DELETE PA的时候B类和A类应该都会从内存中清除,那么它也只会执行A类中的析构函数吗?

[caitian6]

[Quote=引用 13 楼 zjfhgdx 的回复:]
前面的很简单只是后面

new了一个B类,
当DELETE PA的时候B类和A类应该都会从内存中清除,那么它也只会执行A类中的析构函数吗?
[/Quote]

A *pa = new B(10);
pa 是 指向A类的指针， 并不是 指向B 类的指针

[once_and_again]

有句关键的话，我记乱了
就是 纯虚函数必须是 public
非纯虚函数一定是 protecte
还是颠倒过来，

[once_and_again]

纯虚析构函数，之误.