[接上]多维数组比较与辨识：

float(*cp) [30] [20];  //三级指针；

      float (*bp) [20];     //二级指针；

      cp=new float [1] [20] [30];

      bp=new float [30] [20];

     两个数组都是由600个浮点数组成，前者是只有一个元素的三维数组，每个元素为30行20列的二维数组，而另一个是有30个元素的二维数组，每个元素为20个元素的一维数组。

       删除这两个动态数组可用下式：

delete [] cp;  //删除（释放）三维数组；

delete [] bp;  //删除（释放）二维数组；

动态创建和删除一个m*n个元素的数组。采用指针数组方式来完成二维数组的动态创建：。

const int m=4,n=6; //行列数

//1、先看二维数组的动态创建：

void main(){

    double **data;

    data = new double*[m]; //申请行

    if ((data ) == 0)

     { cout << "Could not allocate. bye ...";

        exit(-1);}

    for(int j=0;j<m;j++)

     { data[j] = new double[n]; //设置列

        if (data[j] == 0)

        { cout << "Could not allocate. Bye ...";

           exit(-1);}  } //空间申请结束，下为初始化

    for (int i=0;i<m;i++) 

       for (int j=0;j<n;j++)  data[i][j]=i*n+j;

display(data); //2、二维数组的输出，此处略。

//3、再看二维数组的撤销与内存释放：

   for (int i=0;i<m;i++)

         delete[] data[i];

      //注意撤销次序，先列后行，与设置相反

    delete[] data;

    return;

}

二维数组的内存释放可以做成函数，

调用语句de_allocate(data)；

void de_allocate(double **data){

       for (int i=0;i<m;i++)    delete[] data[i];

       delete[] data;

       return; }

通过指针使堆空间，编程中的几个可能问题

⑴.动态分配失败。返回一个空指针（NULL），表示发生了异常，堆资源不足，分配失败。

          data = new double*[m]; //申请行

          if ((data ) == 0)……

⑵.指针删除与堆空间释放。删除一个指针p（delete p;）实际意思是删除了p所指的目标（变量或对象等），释放了它所占的堆空间，而不是删除ｐ本身，释放堆空间后，ｐ成了空悬指针，不能再通过p使用该空间，在重新给p赋值前，也不能再直接使用p。

⑶.内存泄漏（memory leak）和重复释放。new与delete 是配对使用的， delete只能释放堆空间。如果new返回的指针值丢失，则所分配的堆空间无法回收，称内存泄漏，同一空间重复释放也是危险的，因为该空间可能已另分配，所以必须妥善保存new返回的指针，以保证不发生内存泄漏，也必须保证不会重复释放堆内存空间。

⑷.动态分配的变量或对象的生命期。无名对象的生命期并不依赖于建立它的作用域，比如在函数中建立的动态对象在函数返回后仍可使用。我们也称堆空间为自由空间（free store）就是这个原因。但必须记住释放该对象所占堆空间，并只能释放一次，在函数内建立，而在函数外释放是一件很容易失控的事，往往会出错。  

 

编程学习－动态内存分配－基于C++类

堆对象与构造函数

　通过new建立的对象要调用构造函数，通过deletee删除对象也要调用析构函数。

CGoods *pc;

pc=new CGoods;  //分配堆空间，并构造一个无名

                               //的CGoods对象；

…….

delete pc;  //先析构，然后将内存空间返回给堆；

    堆对象的生命期并不依赖于建立它的作用域，所以除非程序结束，堆对象（无名对象）的生命期不会到期，并且需要显式地用delete语句析构堆对象，上面的堆对象在执行delete语句时，C++自动调用其析构函数。

正因为构造函数可以有参数，所以new后面类（class）类型也可以有参数。这些参数即构造函数的参数。

但对创建数组，则无参数，并只调用缺省的构造函数。见下例类说明：

class CGoods{

           char Name[21];

           int  Amount;

           float Price;

           float Total value;

public:

  CGoods(){}; //缺省构造函数。因已有其他构造函数，系统不会再自动生成缺省构造，必须显式说明。

  CGoods(char* name,int amount ,float price){

            strcpy(Name,name);

            Amount=amount;

            Price=price;

            Total_value=price*amount;　　}

            ……

}；//类声明结束

//下面注意如何使用：

void main(){

  int n;

  CGoods *pc,*pc1,*pc2;

  pc=new CGoods(“夏利2000”，10，118000);

  //调用三参数构造函数

  pc1=new CGoods();  //调用缺省构造函数

  cout<<’输入商品类数组元素数’<<endl;

  cin>>n;

  pc2=new CGoods[n];

 //动态建立数组，不能初始化，调用n次缺省构造函数  

  ……

  delete pc;

  delete pc1;

  delete []pc2;  }

此例告诉我们堆对象的使用方法：

申请堆空间之后构造函数运行；

释放堆空间之前析构函数运行；

再次强调：由堆区创建对象数组，只能调用缺省的构造函数，不能调用其他任何构造函数。如果没有缺省的构造函数，则不能创建对象数组。

 

浅拷贝与深拷贝

对象的构造，也可以由拷贝构造函数完成，即用一个对象的内容去初始化另一个对象的内容。

此时，若对象使用了堆空间（注意和“堆对象”区分），就有深、浅拷贝的问题，不清楚则很容易出错。

1、什么是浅拷贝？

2、浅拷贝可能带来什么问题？

3、什么是深拷贝？

4、深拷贝的实现方法？

什么是浅拷贝

缺省拷贝构造函数：用一个对象的内容初始化另一个同类对象，也称为缺省的按成员拷贝，不是对整个类对象的按位拷贝。这种拷贝称为浅拷贝。

class CGoods{

           char *Name; //不同与char Name[21] ?

           int  Amount;

           float Price; float Total_value;

public： CGoods(){Name=new char[21];}

 CGoods(CGoods & other){ //缺省拷贝构造内容：

            this->Name=other.Name;

            this->Amount=other.Amount;

            this->Price=other.Price;

           this->Total_value="/blog/other.Total_value;}

~CGoods(){delete Name;}//析构函数

};  //类声明结束

 

浅拷贝带来的问题

void main(){

     CGoods pc;  //调用缺省构造函数

   CGoods pc1(pc);   //调用拷贝构造函数

} //程序执行完，对象pc1和pc将被析构，此时出错。

析构时，如用缺省的析构函数，则动态分配的堆空   

        间不能回收。

如果用有“delete Name;”语句的析构函数，则先

        析构pc1时，堆空间已经释放，然后再析构pc   

       时出现了二次释放的问题。

这时就要重新定义拷贝构造函数，给每个对象独

        立分配一个堆字符串，称深拷贝。

深拷贝——自定义拷贝构造

CGoods(CGoods & other){ //自定义拷贝构造

            this->Name=new char[21];

            strcpy(this->Name,other.Name);

            this->Amount=other.Amount;

            this->Price=other.Price;

            this->Total_value="/blog/other.Total_value;}

例子：定义copy structor和拷贝赋值操作符(copy Assignment Operator）实现深拷贝。

//学生类定义：

class student{

     char *pName; //指针成员

public:

     student();

     student(char *pname);

     student(student &s); //拷贝构造函数

     ~student();

     student & operator=(student &s);

                                    //拷贝赋值操作符

};

//缺省构造函数：

student::student()

 {   pName=NULL; cout<<“Constructor缺省\n";  }

//带参数构造函数：

student::student(char *pname){

       if(pName=new char[strlen(pname)+1])      

              strcpy(pName,pname);

       cout <<"Constructor" <<pName<<endl;}

//拷贝构造函数：

student::student(student &s){

    if(s.pName!=NULL){

        if(pName=new char[strlen(s.pName)+1])

               strcpy(pName,s.pName); }

  //加1不可少，否则串结束符冲了其他信息，析构会出错！

    else pName=NULL;

    cout <<"Copy Constructor" <<pName<<endl;}

//析构函数：

student::~student(){

    cout<<"Destructor"<<pName<<endl;

    if(pName) delete[ ]pName;} //释放字符串

//

阅读全文 | 回复(2) | 引用通告 | 编辑

标签：编程 

• 上一篇：编程学习－二维字符串数组的初始化－动态内存分配
• 下一篇：业界推动高清视频应用进入消费主流

Re:编程学习－动态内存分配－基于C++类

你好，我是一个他、数字图像处理初学者，我想请教一个问题：请问一段视频图像，通过分帧采集之后，如何从这些静态图像中选择具有代表性的部分帧？或者是否可以在分割的时候就考虑到这个因素？

我的邮箱是：gxh_820810@163.com

或xhgu@cqu.edu.cn

期待你的回音。

一个冒昧的小辈

个人主页 | 引用 | 返回 | 删除 | 回复

Re:编程学习－动态内存分配－基于C++类

[接上]//拷贝赋值操作符：

student & student::operator=(student &s){

    if(pName) delete[ ]pName; /*如原来已分配，应先撤销，再重分配*/

    if(s.pName){

       if(pName=new char[strlen(s.pName)+1])  

             strcpy(pName,s.pName);}

    else pName=NULL;

cout <<"Copy Assign operator" <<pName<<‘\n’;

    return *this;}

堆内存是最常用的需要自定义拷贝构造函数的资源，但不是唯一的，如打开文件等也需要。

   如果类需要析构函数来释放某些资源，则类也需要一个自定义的拷贝构造函数。此时，对象的拷贝就是深拷贝了。

个人主页 | 引用 | 返回 | 删除 | 回复

发表评论：

昵称：

密码：

主页：

标题：

正在载入。。。。。。