嵌入式软件开发------指针和内存释放的问题分析

指针和内存的问题关于指针分配是否要delete的问题:

1.请大家在使用指针变量时遵守以下几点，可以让你们在编程时 

少许多的麻烦，以下假设p为某个类型的指针变量。 

(1)定义指针： 

   (a)定义指针变量时赋初值为type* p=NULL; 

      若是指针数组，刚用循环语句集体赋初值为NULL， 

      或调用api函数ZeroMemory(指针数组开始地址，0,数组大小(按字节算)); 

(2)使用指针： 

   (a)确定是否已经指向某个地址。 

      请用if(p!=NULL) 

             正常语句; 

          else 

            TRACE("p points to NULL"); 

      使用TRACE(..)函数对调试非常有用 

     

   (b)要确定指针变量所指向的变量的类型。 

      如在使用语句p++,p--时，更要如此，有时还要注意到 

      类型的强制转换，以及类型强制转换带来的后果。 

      同时,最好先用pOld=p保存起来

   (c)当动态申请内存时，如p=new 某个类型; 

      在这种用途时，一般来说p之前不会指向某个普通变量(视具体程序而不同)， 

      所以可采用 

      if(p==NULL) 

      {

        p=new 某个类型; 

        if ( !p ) { … }      //在new以后立刻检查是否得到有效的空间 

      }

      else 

        出错处理;     

      若是p在new之前已经不等于0，则很可能是之前已经为p申请某些动态内存， 

      需要及时释放。 

      对应于这种情况，因此在释放p所指向的内存时， 

      建议使用 

      if(p!=NULL) 

      { 

          delete p;   //  (或delete []p;看情况了) 

          p=NULL;   // 请注意最好加上这一句。 delete操作只是释放p所指向的内存，

但是并不将

                   // p赋值为NULL。  

      } 

    (d)请最好不要将两个指针变量指向同一块动态内存， 

       因为其中一个释放了动态内存以后，虽然另一个指针 

       所指向的内存地址不等于NULL，但是因为内存已被释放， 

       所以若用这个指针时，则会出错。 

       如果需要将两个指针指向同一个动态内存的话， 

       则在编程时要特别小心。 

(3)释放指针所指向的动态内存时： 

     (a)上面已经讲到两种情况 

     (b)最好将类的成员变量中的指针全部赋值为NULL(有时则可以为NULL， 

        或肯定不能赋为NULL，如在成员变量是static类型时，视程序而定)。 

2.在类里面用到动态分配内存的指针,下面是规范的4部曲

(1) 构造函数中    m_pData=NULL;   (2)重复更新和分配   if (m_pData!=NULL)     

delete []m_pData;// or  delete m_pData;   m_pData=new .....   (3).所有使用指针的

地方   if(m_pData!=NULL)     {     }   else 

    TRACE("p points to NULL"); (4).析构函数   if(m_pData)      delete []m_pData;

    // or  delete m_pData; 

<说明一点>:类里面用到指针成员变量是很容易出错的一个地方;

我们把一个指针作为成员变量，在某个或者某些成员函数中，要多次给他分配内存，当然，

我们再分配之前必须保证它原先没有指向任何内存（否则就内存泄漏了）

如果判断呢，我想大部分人会这么写：

if (m_pData!=NULL)     delete []m_pData;// or  delete m_pData;   m_pData=new .

....   

就是用m_pdata是否为NULL来判断指针是否已经有内存，

那么如果我在别的地方将这块内存delete后没有把指针置为NULL，那么碰到

这样的判断语句会发生什么样的情况，想必大家都看到了。    

3.内存分配和释放的分工问题。   我觉得应该明确分配和释放的角色，一个指针只有唯一

一个对象分配，也有唯一一个对 象释放。 绝对应该避免多头分配释放问题。 COM中的内存

分配原则就是很好的例子 COM接口的参数，有三种方向类型[in],[out],[in,out] [in]指针

的内存，是在调用者分配空间调用者释放 [out]指针的内存，是被调用者分配，调用者释放

，且调用者不需要事先初始化 [in,out]指针内存，调用者必须初始化，被调用者可以根据

需要是否重新分配内存 最后由调用者进行清理。 不管哪种形式，一个地址的分配和释放总

是唯一的。 所以，在 FatMouse刚才的那个例子中 p到底是由子类维护还是父类维护呢？ 

事实上，由于子类的析构函数自动调用父类的析勾函数 子类不需要对父类的指针进行释放

。 

4.动态分配内存后不释放是肯定会有内存泄漏的

  有一种说法是程序退出的时候编译器是会做内存回收的,我看了一下代码,发现退出main的

时候是会做一些清理工作，主要是把栈清除一下； 

运行的时候的调用栈是这样： 

main() 

maincrtstrartup() 

kernel32 

其中： 

mainCRTStartup: 

。。。。。。 

00421F30   mov         edx,dword ptr [__environ (0047c3dc)] 

00421F36   push        edx 

00421F37   mov         eax,[___argv (0047c3d4)] 

00421F3C   push        eax 

00421F3D   mov         ecx,dword ptr [___argc (0047c3d0)] 

00421F43   push        ecx 

00421F44   call        @ILT+550(_main) (0040122b) 

00421F49   add         esp,0Ch 

00421F4C   mov         dword ptr [mainret],eax 

00421F4F   mov         edx,dword ptr [mainret] 

00421F52   push        edx 

00421F53   call        exit (00426040) 

。。。。。 

先是向栈压入edx,随后压入命令行参数，在返回之前pop出命令行参数,edx，返回之后， 

把返回值保留在edx中，随后再次压入栈内，调用exit() 

并没有垃圾内存的回收（即delete那块new出来的内存/现在已经没有指针变量可以标示 

它了) 

之所以你没有delete而在退出程序后觉得好像没有内存泄漏我想是操作系统为你做了垃圾

collector的

工作,一个操作系统要是连这个都做不到  那他也太懒了

5.关于内存释放的时机

有一种习惯说是在退出程序的时候释放所有已经分配的内存,同时指针置为null,我认为到了

退出时再释放内存已经太晚了，而且没有任何意义(如上所见反正系统会帮你释放得),释放

内存应该在不再使用时就立刻释放。

常见的内存分配和使用错误

 

1) 内存的申请和分配并没有成功，但程序员却使用了它。一些新手经常会犯这种错误，他们并不会留意到内存没有分配成功。判断指针的值是否为NULL可以有效地避免这种错误。

2) 内存的分配已经成功，但是却没有进行初始化就直接使用它了。首先是观念上的问题，很多人都没有在使用指针前要初始化这样的习惯，然而这个习惯却是很重要的，希望大家一定要强迫自己养成。第二就是主观地认为自己申请的内存的缺省值为0，这样想是没有什么道理的，内存分配后的值是不确定的。

3) 上面的两种工作都已经做好了（已经成功申请并初始化完成），但是操作时却越界了。

4) 申请了内存，使用完了却忘记了释放，导致内存泄露。这样的错误可以形容为一个恶性的肿瘤，它不会马上要你的命，但是它会慢慢地吞噬你的系统资源，直到你的程序彻底完蛋。

5) 你很小心地释放了内存，但是却又使用了它。由于程序很复杂或者调用顺序出错，这样可能导致出现上面的错误。

 

指针---一把伟大的双刃剑

 

我真的非常佩服发明指针的人，他简直太伟大了。能使用如此简洁地方法将复杂的内存结构描述的如此清楚，这本身就是一种伟大的成就。但是，指针之于程序员如同武器之于士兵，用好了可以威力无比，用不好则害人害己。

我先说说指针和数组的区别。数组名对应着一块内存，它的地址、容量在其生命周期中是不可变的，只有数组内容是可变的。指针可随时指向任何类型的内存，它的特点就是“变”。指针远比数组灵活，但也更危险。

数组名是不能直接进行赋值和比较的。如果你向要将数组a赋值给数组b，不能直接用赋值语句b = a ，这样会令编译器产生错误的。必须使用标准的库函数strcpy来进行赋值。相同地，要比较a和b的内容是否相同，不能使用普通的逻辑判断if（b==a），也要应用库函数strcmp来判断。

//数组……

char a[] = “hello”;

char b[100];

strcpy(b, a); // b = a is wrong

if (strcmp(b, a) == 0) //if (b == a) is wrong

cout<<b<<endl;

//指针……

int len = strlen(a);

char *p = (char *)malloc(sizeof(char)*(len+1));

strcpy(p, a);

if (strcmp(p, a) == 0)

cout<<p<<endl;

free(p);

在计算内存容量的时候有一点是必须要指出的，那就是sizeof计算数组是计算它的实际的内存容量，而计算指针时则永远都是4个字节。C++是永远没有办法知道指针所指的内存容量，除非在申请时记住它。

 

free和delete如何对付指针？

 

程序员都知道它们是用来释放申请的内存的，但是却很少有人注意到指针本身并没有发生什么变化。各位可以在VC中使用单步跟踪一下，你们会惊奇地发现当指针p被调用了free后它的地址值并没有改变，只是该地址对应的内存中原来有意义的值变成了垃圾，“p”却还是指向的这块内存。记住，一定要第一时间将p的值设为NULL，否则会让别人以为p是一个有意义的指针而误使用它（当别人使用该指针时会判断指针的值是否为NULL，如果不为NULL就会以为它有意义）。

也就是说调用了free(p)之后，p仍然指向那块内存，假若不显示设置为NULL的话，以后就不能使用if (NULL == p)来判断p是否释放

char *p = (char *)malloc(100);

strcpy(p, “hello”);

free(p); // the address of “p” is not changed.

….

if (NULL != p) //it will return TRUE

strcpy(p, “world”); //Wrong!!!

下面提两点，让大家可以防止上面的情况出现：

1) 指针声明后要马上初始化。因为指针出现的缺省值是随机的，所以一定要赋值为NULL，然后再使用。

2) 调用了free和delete后一定要将指针赋值为NULL。原因上面已经提过了，就不再赘述了。

C++父类子类指针函数调用注意事项（虚拟函数与多型Polymorphism）

1，如果以一个基础类指针指向一个衍生类对象，那么经由该指针只能访问基础类定义的函数

2，如果以一个衍生类指针指向一个基础类对象，必须先做强制转型动作（explicit cast），这种做法很危险，也不符合生活习惯，在程序设计上也会给程序员带来困扰。

3，如果基础类和衍生类定义了相同名称的成员函数，那么通过对象指针调用成员函数时，到底调用那个函数要根据指针的原型来确定，而不是根据指针实际指向的对象类型确定。

 

虚拟函数就是为了对“如果你以一个基础类指针指向一个衍生类对象，那么通过该指针，你只能访问基础类定义的成员函数”这条规则反其道而行之的设计。

 

如果你预期衍生类由可能重新定义一个成员函数，那么你就把它定义成虚拟函数（ virtual ）。

 

polymorphism就是让处理基础类别对象的程序代码能够通透的继续适当地处理衍生类对象。

 

纯虚拟函数：

virtual void myfunc ( ) =0;

纯虚拟函数不许定义其具体动作，它的存在只是为了在衍生类钟被重新定义。只要是拥有纯虚拟函数的类，就是抽象类，它们是不能够被实例化的。如果一个继承类没有改写父类中的纯虚函数，那么他也是抽象类，也不能被实例化。

 

抽象类不能被实例化，不过我们可以拥有指向抽象类的指针，以便于操纵各个衍生类。

 

虚拟函数衍生下去仍然是虚拟函数，而且还可以省略掉关键字“virtual”。