指针操作超越变量作用范围的问题(高质量c++)

http://community.csdn.net/Expert/topic/4494/4494006.xml?temp=.9375269

下面这是高质量c++上的:
指针操作超越了变量的作用范围。这种情况让人防不胜防,示例程序如下:
class A
{
public:
void Func(void){ cout << “Func of class A” << endl; }
};
void Test(void)
{
A *p;
{
A a;
p = &a; // 注意 a 的生命期
}
p->Func(); // p 是“野指针”
}
函数Test 在执行语句p->Func()时,对象a 已经消失,而p 是指向a 的,所以p 就
成了“野指针”。
但运行这个程序没出错。书上说原因是a虽然退栈了,但仅仅是调用了一下析构函数而已,而析构函数其实没干什么重要的事情,它并没有清楚a的内存,所以a仍然好好地在那里放着,只是你无法在程序外直接访问而已。

-------------
怎么说析构函数没干什么事情?析构函数不会清楚a的内存?谁给解释下上面的原因

=========================================

析构函数也是一个函数, 只是不用程序员自己显示调用, 在离开局部变量的作用域的时候, 首先将按照变量声明的逆序调用析构函数, 然后释放局部变量的内存空间。仍然使用释放后的内存空间的行为是未定义的。
=========================================

由于a对象是在语句块中,所以出了语句块,a对象自动调用了析构函数,销毁了对象,但是p指向的内存没有变,只是那块内存已经不被程序所控制,他可能随时被修改,再分配。析构函数所作的只是告诉程序,这块内存已经不再为对象a所用,但是并没有把其中内容擦除,(我想这也是我们申请变量要初始化的原因吧 )
所以程序能运行出结果,也不足为怪,但是就稳定性来说,是大忌,因为极有可能你运行出来的结果可能被修改掉了,而这时候你却误认为是正确的。
=========================================

主要的原因是A类的Func是个几乎与A类无关的函数,如果A类这样定义,代码是会出错的
class A
{
public:
void Func(void){ num = 1; cout << “Func of class A” << endl; }
int num;
};

这是因为函数里面要引用它的成员变量,但是却被析构了,类函数里面调用的隐含this指针无效。

其实楼主的代码写成以下的样子也能无错的跑
A *p;
p->Func();
主要的原因是A类的Func是个几乎与A类无关的函数,如果A类这样定义,代码是会出错的
class A
{
public:
void Func(void){ num = 1; cout << “Func of class A” << endl; }
int num;
};

这是因为函数里面要引用它的成员变量,但是却被析构了,类函数里面调用的隐含this指针无效。

其实楼主的代码写成以下的样子也能无错的跑
A *p;
p->Func();
=======================================

我要是创建对象A a;当a离开作用域销毁时,调用析构函数,只是释放了a对象,a.num这块内存的内容还是存在的(没被析构函数清除?)?只是a不存在了,不能再访问num对应这块内存了?
==========================
当释放了a对象,a.num这块内存还没改变的时候,也还能通过指针访问到这块内存,读出正确的内容。但这块内存已不在程序控制之下了。假如是个多线程程序,A线程刚刚释放这块内存,B线程马上又分配一块内存,就可能用到A线程刚刚释放的这块内存,这时A线程访问这块内存的野指针访问到的就是非法内容了。其实这个问题,如果写成函数外通过指针访问函数内的局部变量应该更好理解。这是我的理解。
========================================

所谓的a析构了,即对象a占用的空间已经释放,释放并不会改变原来空间中的任何内容,只是可以再次分配使用而已。所以p虽然指向的空间已经释放,但是它指向的数据还是有效的(还是用户想要的),但是这样毕竟不是总是安全的。

程序可以正常执行的另一个原因为。类A中没有任何的数据,p->Func();在编译就绑定了。我们可以先面的两个例子说明:
#include<stdio.h>
class A
{
private:
int a;
public:
     A(){ a=4;}
void Func(void){ printf("%d",a);}
};
void Test(void)
{
A *p;
{
A a;
p = &a; // 注意 a 的生命期
p->Func();
}
p->Func(); // p 是“野指针”
}
int main()
{
  Test();
  return 1;
}
结果:44

结果正确,虽然a已经析构,但是a的内容仍然存在。
#include<stdio.h>
class A
{
private:
int a;
public:
     A(){ a=4;}
void Func(void){ printf("%d",a);}
};
void Test(void)
{
A *p;
{
A a;
p = &a; // 注意 a 的生命期
p->Func();
}
{
 int a=5;
}
p->Func(); // p 是“野指针”
}
int main()
{
  Test();
  return 1;
}
结果:45

结果不正确,a已经析构,但是a的内容已经被int a的值5覆盖掉了。
#include<stdio.h>
class A
{
public:
     A(){}
void Func(void){ printf("output");}
};
void Test(void)
{
A *p;
{
A a;
p = &a; // 注意 a 的生命期
p->Func();
}
{
 int a=5;
}
p->Func(); // p 是“野指针”
}
int main()
{
  Test();
  return 1;
}
结果:outputoutput
结果正确,因为类A中没有数据,所以对象的存在没有任何实际的意义,因为对象没有状态。
p->Func().不会修改对象,所以正确。

阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页