64,649
社区成员
发帖
与我相关
我的任务
分享帮忙看一道c++题，急
#include<iostream>
using namespace std;
class A
{
public:
A(int n):val(n){}
protected:
int val;
};
class B:public A
{
public:
B(int n):A(n)
{
pB=(n>0? new B(n-1):0);
}
~B(){delete pB;}
void Display()
{
cout << val << endl;
if(pB!=0)pB->Display();
}
private:
B *pB;
};
int main()
{
B b(4);
b.Display();
return 0;
}
程序的运行结果是：4
3
2
1
0
但我不理解为什么结果会是这样，我的想法是：在B的构造函数里，会自身递归调用，最终pB=0,这样在Display()函数里输出一个0
请帮我分析程序的执行过程，先谢谢各位！！！
using namespace std;
class A
{
public:
A(int n):val(n){}
protected:
int val;
};
class B:public A
{
public:
B(int n):A(n)
{
pB=(n>0? new B(n-1):0);
}
~B(){delete pB;}
void Display()
{
cout << val << endl;
if(pB!=0)pB->Display();
}
private:
B *pB;
};
int main()
{
B b(4);
b.Display();
return 0;
}
程序的运行结果是：4
3
2
1
0
但我不理解为什么结果会是这样，我的想法是：在B的构造函数里，会自身递归调用，最终pB=0,这样在Display()函数里输出一个0
请帮我分析程序的执行过程，先谢谢各位！！！
...全文
请发表友善的回复…
发表回复
pengpeng5047 2009-01-17
- 打赏
- 举报
明白，谢谢各位了，快过年了，在此给大家拜个早年！新年快乐！
lizhaohu 2009-01-14
- 打赏
- 举报
我单步调试了一下，的确是递归，好像是链表什么的
Laura_li 2009-01-14
- 打赏
- 举报
你初始化的时候调用了类里面的递归函数
但是每次都实例化了一个对象后就调用了b.Display（）函数所以就会显示出来的啊
但是每次都实例化了一个对象后就调用了b.Display（）函数所以就会显示出来的啊
FancyMouse 2009-01-14
- 打赏
- 举报
>pA=(num>0? &A(num-1):0);
构造函数结束，A(num-1)释放，pA变野指针么
构造函数结束，A(num-1)释放，pA变野指针么
iory_526 2009-01-14
- 打赏
- 举报
长见识了
joly_zl 2009-01-14
- 打赏
- 举报
Mark 果然是个链表
toadzw 2009-01-13
- 打赏
- 举报
没有内存泄露，最后都释放了
tocpve 2009-01-13
- 打赏
- 举报
学习了
weixieming 2009-01-13
- 打赏
- 举报
[Quote=引用 28 楼 obkof 的回复:]
这个会有内存泄露的！！
除了第一个”对象“是在栈上实现之外，后面它指针指向的对象都是通过new的方式在堆上实现，而c++似乎没有删除堆上指针指向的对象能力（这个”堆上“资源的回收可以用gc来实现）；其实这个递归实现有点像函数式编程里的”闭包“实现。
如有错误，请高手指正。
下面是代码分析。。。
[/Quote]
没有内存泄露，最后都释放了
这个会有内存泄露的！！
除了第一个”对象“是在栈上实现之外，后面它指针指向的对象都是通过new的方式在堆上实现，而c++似乎没有删除堆上指针指向的对象能力（这个”堆上“资源的回收可以用gc来实现）；其实这个递归实现有点像函数式编程里的”闭包“实现。
如有错误，请高手指正。
下面是代码分析。。。
[/Quote]
没有内存泄露，最后都释放了
weixieming 2009-01-13
- 打赏
- 举报
B(int n):A(n) ------------------B1
{ ------------------------------B2
pB=(n>0? new B(n-1):0); --------B3
}
A(int n):val(n){} --------------A1
B b(4);时就执行B的构造函数B1，执行到B2时就执行到A1，使val=4；然后执行B3，于是执行B1，接着又执行A1，使val=3；···如此直到n=0，
然后执行
void Display()
{
cout << val << endl;-----------C1
if(pB!=0)pB->Display();--------C2
}
输出依次为4，3，2，1，0接着delete pB,（共5次）这是个队列，先进先出
{ ------------------------------B2
pB=(n>0? new B(n-1):0); --------B3
}
A(int n):val(n){} --------------A1
B b(4);时就执行B的构造函数B1，执行到B2时就执行到A1，使val=4；然后执行B3，于是执行B1，接着又执行A1，使val=3；···如此直到n=0，
然后执行
void Display()
{
cout << val << endl;-----------C1
if(pB!=0)pB->Display();--------C2
}
输出依次为4，3，2，1，0接着delete pB,（共5次）这是个队列，先进先出
obkof 2009-01-12
- 打赏
- 举报
为了简化，其实基类可以去除，
#include <iostream>
using namespace std;
class A{
private:
int value;
A* pA;
public:
A(int num):value(num){
pA=(num>0? new A(num-1):0);
}
~A(){ delete pA; }
void display(){
cout<<value<<endl;
if (pA!=0)
{
pA->display();
}
}
};
int main(){
A a(4);
a.display();
system("pause");
return 0;
}
这个可以实现，和楼主差不多；
而下面这样就不行：因为不用new，都是在栈上产生对象，（深层的机理还请高手解释）；
#include <iostream>
using namespace std;
class A{
private:
int value;
A* pA;
public:
A(int num):value(num){
pA=(num>0? &A(num-1):0);
}
~A(){ delete pA; }
void display(){
cout<<value<<endl;
if (pA!=0)
{
pA->display();
}
}
};
int main(){
A a(5);
a.display();
system("pause");
return 0;
}
#include <iostream>
using namespace std;
class A{
private:
int value;
A* pA;
public:
A(int num):value(num){
pA=(num>0? new A(num-1):0);
}
~A(){ delete pA; }
void display(){
cout<<value<<endl;
if (pA!=0)
{
pA->display();
}
}
};
int main(){
A a(4);
a.display();
system("pause");
return 0;
}
这个可以实现，和楼主差不多；
而下面这样就不行：因为不用new，都是在栈上产生对象，（深层的机理还请高手解释）；
#include <iostream>
using namespace std;
class A{
private:
int value;
A* pA;
public:
A(int num):value(num){
pA=(num>0? &A(num-1):0);
}
~A(){ delete pA; }
void display(){
cout<<value<<endl;
if (pA!=0)
{
pA->display();
}
}
};
int main(){
A a(5);
a.display();
system("pause");
return 0;
}
obkof 2009-01-12
- 打赏
- 举报
这个会有内存泄露的！！
除了第一个”对象“是在栈上实现之外，后面它指针指向的对象都是通过new的方式在堆上实现，而c++似乎没有删除堆上指针指向的对象能力（这个”堆上“资源的回收可以用gc来实现）；其实这个递归实现有点像函数式编程里的”闭包“实现。
如有错误，请高手指正。
下面是代码分析。。。
除了第一个”对象“是在栈上实现之外，后面它指针指向的对象都是通过new的方式在堆上实现，而c++似乎没有删除堆上指针指向的对象能力（这个”堆上“资源的回收可以用gc来实现）；其实这个递归实现有点像函数式编程里的”闭包“实现。
如有错误，请高手指正。
下面是代码分析。。。
长安宁 2009-01-12
- 打赏
- 举报
pB=(n>0? new B(n-1):0);
这样 new 出来的东西，在进行进栈
这样 new 出来的东西，在进行进栈
maosher 2009-01-12
- 打赏
- 举报
一共是五个对象呀，一个对象指向下一个比它小的
tangshuiling 2009-01-12
- 打赏
- 举报
[Quote=引用 23 楼 go_away 的回复:]
请问这里的栈的进出与b的对象模型的构造是怎样联系起来的？
我们这里看到了栈的进出，然后就是b的Display，中间是怎么联系起来的呢？
请赐教。
[/Quote]
哪里是b的Display;楼主你自己的代码是if(pB!=0)pB->Display();是pB的方法pB对应了三个对象的地址植，怎么会是
一个b对象呢，显示的val=4就是b对象产生的值（此时的val为this->val)
其它的是pB（pb1,pb2,pb3)产生的，别混为一坛
请问这里的栈的进出与b的对象模型的构造是怎样联系起来的？
我们这里看到了栈的进出，然后就是b的Display，中间是怎么联系起来的呢？
请赐教。
[/Quote]
哪里是b的Display;楼主你自己的代码是if(pB!=0)pB->Display();是pB的方法pB对应了三个对象的地址植，怎么会是
一个b对象呢，显示的val=4就是b对象产生的值（此时的val为this->val)
其它的是pB（pb1,pb2,pb3)产生的，别混为一坛
zgqiangha 2009-01-12
- 打赏
- 举报
MARK
go_away 2009-01-12
- 打赏
- 举报
[Quote=引用 11 楼 tangshuiling 的回复:]
如果楼主对递归的栈结构理解了就不会由此一问，简单的分析如下：
C/C++ codeB(intn):A(n)
{
pB=(n>0?newB(n-1):0);
}
B b(4);//用4初始化A类成员val,val=4//此时n=4满足大于0的条件，调用new B(3),同时栈要维护现场，存储 val=4,pb=new B(3)产生的对象地址设为pb1 以及函数的下个语句地址，此时是}就相当于return依次类推栈中保存了 (val=4,pb1) (val=3,pb2) (val=2,pb3) (val=1,pb4) 最后val=0，pb=0,遇到}符…
[/Quote]
请问这里的栈的进出与b的对象模型的构造是怎样联系起来的？
我们这里看到了栈的进出，然后就是b的Display，中间是怎么联系起来的呢？
请赐教。
如果楼主对递归的栈结构理解了就不会由此一问，简单的分析如下：
C/C++ codeB(intn):A(n)
{
pB=(n>0?newB(n-1):0);
}
B b(4);//用4初始化A类成员val,val=4//此时n=4满足大于0的条件，调用new B(3),同时栈要维护现场，存储 val=4,pb=new B(3)产生的对象地址设为pb1 以及函数的下个语句地址，此时是}就相当于return依次类推栈中保存了 (val=4,pb1) (val=3,pb2) (val=2,pb3) (val=1,pb4) 最后val=0，pb=0,遇到}符…
[/Quote]
请问这里的栈的进出与b的对象模型的构造是怎样联系起来的？
我们这里看到了栈的进出，然后就是b的Display，中间是怎么联系起来的呢？
请赐教。
liberpc 2009-01-10
- 打赏
- 举报
学习了
小曦子 2009-01-10
- 打赏
- 举报
学习一下..看一次看到这样的情况..
mabo321 2009-01-10
- 打赏
- 举报
[Quote=引用楼主 pengpeng5047 的帖子:]
但我不理解为什么结果会是这样，我的想法是：在B的构造函数里，会自身递归调用，最终pB=0,这样在Display()函数里输出一个0
[/Quote]
int main()
{
B b(4);
b.Display();
return 0;
}
先构造一个b b中又构造了4个无名对象。
b.Display(); //这是b的方法，所以是从4开始递归的……
但我不理解为什么结果会是这样，我的想法是：在B的构造函数里，会自身递归调用，最终pB=0,这样在Display()函数里输出一个0
[/Quote]
int main()
{
B b(4);
b.Display();
return 0;
}
先构造一个b b中又构造了4个无名对象。
b.Display(); //这是b的方法，所以是从4开始递归的……
加载更多回复（19）
