内存管理：new和delete

C++ 指针（二）--c++

一、内存管理：new和delete

1、new操作符：从操作系统获得内存块，并返回该内存块的首地址。

      delete操作符：将new申请的内存返还给操作系统。

开始一个简单的例子：

?

#include <iostream> #include<cstring> using namespace std; int main() {      char * str= "it is a good job!" ;      int len= strlen (str);      char * ptr= new char [len+1];      strcpy (ptr,str);      //ptr=str;  //错误，这样是ptr和str都指向字符串。这里ptr和str应该指向不同的地址。      cout<< "ptr=" <<ptr<<endl;      delete [] ptr;      return 0; }

1） new格式：

char*	ptr	=	new	char	[len+1]
	指针	=	关键字	变量的数据类型	char类型变量的数目（方括号）

         new和malloc：new方法可以返回适当的数据类型的指针；而malloc返回的指针是void类型的指针，必须强制转化才能转化成适当的数据类型指针。

C中的realloc函数可以改变已分配内存空间的大小。C++中没有这样的函数，只能通过new重新申请一个更大或者更小的空间。

2） delete格式：delete【】 要删除的指针

如果new创建的是一个简单的对象，则在删除的时候可不加方括号，如果是数组就必须加括号。

2.使用new的类

?

#include<iostream> using namespace std; class String { public :      String( char * s)      {          int len= strlen (s);          str= new char [len+1];          strcpy (str,s);      }      ~String()      {          cout<< "where?" <<endl;          delete [] str;      }      void display()      {          cout<<str<<endl;      } private :      char * str; }; int main() {      String str= "hello! word!" ;      str.display();      return 0;   }

1）在构造函数中使用new获得内存空间。

2）既然使用new来分配内存空间，因而析构函数也变得很重要。（因为在创建对象的时分配了内存空间，则当这些对象不再需要时就很有必要释放这些空间）。析构函数在对象销毁时自动调用的例程，所以放入delete恰好。

问题：如果一个类的两个对象执行了s1=s2这样的操作（即出现两个对象的指针指向同一个内存地址），而此时一个对象被删除（如含有其中一个对象的调用函数结束后返回时），这样申请的内存地址被收回，这样就导致另一个对象的是一个无效的指针了。

    这个错误一定要重视，因为很容易疏忽。怎样才能写一个更聪明的析构函数呢？？   后面揭晓…

二、对象与指针

1、对象指针

有时在程序的编写时并不知道需要创建多少个对象。当出现这中情况时，就可以在程序运行中使用new来穿件对象。这里，new返回的是一个指向未命名对象的指针。

例子：

?

#include<iostream> using namespace std; class Distance { public :      void getdist();      void showdist(); private :      int feet;      float inches; }; void Distance::getdist() {      cout<< "Enter the feet:" ; cin>>feet;      cout<< "Enter the inches:" ;cin>>inches; } void Distance::showdist() {      cout<< "The feet:" <<feet<<endl;      cout<< "The inches:" <<inches<<endl; } int main() {      Distance dd;      dd.getdist();      dd.showdist();      Distance* ptr= new Distance; // pointer to Distance,points to new Distance object      ptr->getdist();  //这里如果是点运算符就会出错      ptr->showdist(); //因为点运算符要求它的左运算符是一个变量，而ptr为一个指针。      return 0; }

上面标注的地方除了用成员访问运算符（->）表示之外，我们还可以这样(*ptr).getdist(); //ok，but inelegant （圆括号是必须的，因为点运算符的优先级比间接引用运算符要高）.

2、对象指针数组

?

Distance* distptr[100]; distptr[j]= new Distance; //*(distptr+j)=new Distance; distptr->getdist(); distptr->showdist();

注意：数组表示法distptr[j]等价于指正表示法*(distptr+j)，由于是指针数组，上面两种表示的方法的元素还是指针（指向对象的指针）

          distptr->getdist(); 表示执行了由数组distptr的第j个元素 所指向的Distance对象的成员函数。

三、链表

链表提供了一种不使用数组但更为灵活的存储系统，每个数据项都是按照需要通过new来获取的，且数据之间是通过指针链接起来的。

单个数据项之间并不需要和数组元素一样在内存中相邻分配，相反他们可以分散到任何地方。

例子：

?

#include <iostream> using namespace std; struct link {      int data;     //表示对象的单个数据项      link* next;   //指向下一个链接项 }; class linklist { public :      linklist():first(NULL) {}      void addlist( int d);   //增加链接项      void display();        //显示链接内容 private :      link* first; }; void linklist::addlist( int d)  //增加链接项 {      link* newptr= new link; //创建一个新的link结构类型      newptr->data=d;        //将参数的值传递给结构变量data       newptr->next=first;    //指针next指向first指向的任何地址（在这里是链表头）      first=newptr;          //将指针first指向这个新的链接项 } void linklist::display() {      link* nowptr=first;      while (nowptr!=NULL)      {          cout<<nowptr->data<<endl;          nowptr=nowptr->next;  //指针移动到下一个链表的地址      } } int main() {      linklist ll;      ll.addlist(22);      ll.addlist(33);      ll.addlist(44);      ll.display();      return 0; }

注意：在使用link结构的时候含有一个指向同类型结构的指针。同样的在类中也可以这么使用：

?

class sampleclass {      sampleclass* ptr;   //this is fine！      sampleclass obj;    //can't do this！！ };

但是这里要特别注意：虽然类中可以包含一个指向同类型对象的一个指针，但不能包含一个同类的对象。

四、指向指针的指针

看个例子：

?

#include<iostream> #include <string> using namespace std; class person { public :      void SetName()      {          cout<< "Enter name:" ; cin>>name;      }      void PrintfName()      {          cout<<name;      }      string GetName()      {          return name;      } private :      string name; }; int main() {      void bsort(person**, int );     //排序      person* perptr[100];      int n=0;      char ch;      do      {          *(perptr+n)= new person;          (*(perptr+n))->SetName();          n++;          cout<< "Enter another?" ;          cin>>ch;      } while (ch== 'y' );      cout<< "姓名排序前：" ;      for ( int j=0;j<n;j++)      {          perptr[j]->PrintfName();          cout<< " " ;      }      bsort(perptr,n);      cout<< "\n姓名排序后：" ;      for ( int j=0;j<n;j++)      {          perptr[j]->PrintfName();          cout<< " " ;      }      cout<<endl;      return 0; } void bsort(person** ptr, int n)  //排序 {      void order(person**,person**);      int j,k;      for (j=0;j<n-1;j++)          for (k=j+1;k<n;k++)              order(ptr+j,ptr+k); } void order(person** ptr1,person** ptr2)  //比较 {      if ((*ptr1)->GetName()>(*ptr2)->GetName()))      {          person* tem;          tem=*ptr1;          *ptr1=*ptr2;          *ptr2=tem;      } }

1）注意到数据类型person**，表示这些参数被用来传递perptr指针数组的地址。本身perptr数组中存的就是指针，因此指针数组的地址是一个指向指针的指针。

2）因为数组perptr包含的是指针，因而：perptr[j]->PrintfName();  表示执行perptr数组的j号元素所指向的对象的PrintfName()成员函数。

3）(*ptr1)->GetName()；

其中ptr1是一个指向指针的指针，因此(*ptr1)表示指针数组的元素。总体意思就是执行perptr数组的元素(*ptr1)所指向的对象的PrintfName()成员函数。

分类:  c+