精华内容
下载资源
问答
  • 调用函数用new申请空间的释放方法

    千次阅读 2018-07-19 11:56:10
    问题:调用函数用new申请空间,如果不释放则会存在内存泄露问题 调用函数用new申请空间的释放方法 方法一:将要反馈的结果赋值给一个栈元素,栈元素会随着函数调用的完成而自动释放占用的空间。 方法二:用一个...

    问题:调用函数用new申请空间,如果不释放则会存在内存泄露问题

    调用函数用new申请空间的释放方法

    方法一:将要反馈的结果赋值给一个栈元素,栈元素会随着函数调用的完成而自动释放占用的空间。

    方法二:用一个指针p接受这个返回地址,然后再释放这个指针指向的空间

    程序实现

    第一种方案

    #include <iostream>
    #include<string.h>
    
    using namespace std;
    int getMax(int a,int b)
    {
        return (a>b?a:b);
    }
    
    int ** findLCS(const char * a,const char *b)
    {
        int lenA=strlen(a);
        int lenB=strlen(b);
    
        int **c=new int*[lenA+1] ;
        for(int i=0;i<lenA+1;i++)
        {
            c[i]=new int[lenB+1];
        }
    
        for(int i=0;i<lenA;i++)
            c[i][0]=0;
        for(int j=0;j<lenB;j++)
            c[0][j]=0;
    
        for(int i=1;i<=lenA;i++)
        {
            for(int j=1;j<=lenB;j++)
            {
                if(a[i]==b[j])
                {
                    c[i][j]=c[i-1][j-1]+1;
                }
                else
                {
                    c[i][j]=getMax(c[i-1][j],c[i][j-1]);
                }
            }
        }
    
        int res=c[lenA][lenB];
    
        for(int i=0;i<lenA+1;i++)
            delete []c[i];
        delete c;
        return res;
    }
    
    int main()
    {
        char a[100]="abcbdab";
        char b[100]="bdcaba";
        cout<<findLCS(a,b)<<endl;
        return 0;
    }
    

    第二种方案

    #include <iostream>
    #include<string.h>
    
    using namespace std;
    int getMax(int a,int b)
    {
        return (a>b?a:b);
    }
    
    int ** findLCS(const char * a,const char *b)
    {
        int lenA=strlen(a);
        int lenB=strlen(b);
    
        int **c=new int*[lenA+1] ;
        for(int i=0;i<lenA+1;i++)
        {
            c[i]=new int[lenB+1];
        }
    
        for(int i=0;i<lenA;i++)
            c[i][0]=0;
        for(int j=0;j<lenB;j++)
            c[0][j]=0;
    
        for(int i=1;i<=lenA;i++)
        {
            for(int j=1;j<=lenB;j++)
            {
                if(a[i]==b[j])
                {
                    c[i][j]=c[i-1][j-1]+1;
                }
                else
                {
                    c[i][j]=getMax(c[i-1][j],c[i][j-1]);
                }
            }
        }
       
        return c;
    }
    
    int main()
    {
        char a[100]="abcbdab";
        char b[100]="bdcaba";
        int **c=findLCS(a,b);
        cout<<c[strlen(a)][strlen(b)]<<endl;
        int lenA=strlen(a);
        for(int i=0;i<lenA+1;i++)
            delete []c[i];
        delete c;
        return 0;
    }
    

     

    展开全文
  • 申请空间 new、delete

    2018-11-27 14:53:25
     在C语言中,我们申请空间用malloc,calloc,realloc,释放空间为free,在这样的空间申请后,我们需要对申请空间的状态,进行判断,判断是否申请成功,并且需要对没有申请成功的变量进行处理,在这样的情况下,人们...

    new/delete 出现的背景:

            在C语言中,我们申请空间用malloc,calloc,realloc,释放空间为free,在这样的空间申请后,我们需要对申请空间的状态,进行判断,判断是否申请成功,并且需要对没有申请成功的变量进行处理,在这样的情况下,人们难免可能会忘记判断,导致程序出现异常。

    new/delete 实现的原理:

      new、delete ,new[] ,delete[], 在实现原理上依旧是调用C语言中的malloc 和 free 进行实现,但由于对malloc,free进行了调用,因此在内部,new对变量 申请的空间进行了判断,并且对没有申请成功的变量进行了处理。

    1.这是new在C++中的实现方式,其中  _THROW_NCEE(_XSTD bad_alloc, );这是对new  变量 抛出异常

              operator new()函数中可以添加其他的参数,但第一个参数必须是size_t类型的参数

    void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
            {       // try to allocate size bytes
            void *p;
            while ((p = malloc(size)) == 0)
                    if (_callnewh(size) == 0)
                    {       // report no memory
                            _THROW_NCEE(_XSTD bad_alloc, );
                    }
    
            return (p);
            }
    

    2.这是new[] 在C++中的实现,通过其中代码可见 主要是通过调用new 来创建一段连续的空间

    void * operator new[]( size_t cb )
    {
        void *res = operator new(cb);
    
        RTCCALLBACK(_RTC_Allocate_hook, (res, cb, 0));
    
        return res;
    }
    

    3.这是delete 在C++中的实现,由此可见主要是调用free 来释放空间

    void operator delete( void * p )
    {
        RTCCALLBACK(_RTC_Free_hook, (p, 0));
    
        free( p );
    }
    

    4.

    void operator delete[]( void * p )
    {
        RTCCALLBACK(_RTC_Free_hook, (p, 0))
    
        operator delete(p);
    }

    new/delete操作自定义类型的次序:

    1.new:
            1).申请空间:void *__CRTDECL operator new(size_t size字节数) _THROW1(_STD bad_alloc) 
         
                表明依旧是使用C语言中的malloc申请空间,并且进行判断是否申请成功,没有成功,则在函数内部进行处理
                operator new()函数中可以添加其他的参数,但第一个参数必须是size_t类型的参数
                        
            2).调用构造 :对象初始化 
            
        2.delete :
            1).调用析构 :将对象中的资源释放掉
            2).释放空间:void operator delete(void *pUserData) 
                 调用从语言中的free释放空间

                 operator new/ operator delete  基本上不需要重载,除非需要看是在什么时候使用,并且申请多长字节等等信息或者需要查看内存泄漏的情形。
                 
        3.new T[N]:前四个字节(取决于是否有析构函数)放对象的个数。(目的:保证销毁时销毁对象的次数)
    小贴士:这里面申请空间大小有没有多申请4个字节,取决于类成员函数中是否存在析构函数或者编译器是否默认生成析构函数。若类成员函数中没有析构函数,则申请空间时,不多申请4个字节。
            1).operator new[](sizeof(T)*N+4)
                operator new(sizeof(T)*N+4)
                    while(p=malloc(字节数)==NULL))
                    {     if(条件(空间不足的处理))
                            { 抛异常}
                            }
            2).调用N次构造对象:
            
        4.delete[] p:
            1).调用N次析构函数-->释放每个对象的资源,后构造的先析构,成对出现
            2).operator delete[](void* p)-->operator delete(p)--->free(p)

    注意:

    1. new 和 delete 是C++中提出的关键字,不是函数
        2.new 类型,可以初始化,无需强制类型转化
        3.new申请的空间不需要对结果判空(原:
        4.new申请空间  -->会调用构造函数   delete--->调用析构函数
            malloc 不调用构造函数    free 不调用析构函数
            new/delete   new[]/delete[]   malloc/free :匹配使用
              否则:内存泄漏、崩溃

    小问题:若申请空间与释放空间没有匹配使用,则程序会出现什么样的问题?

    答:1.内置类型:如果没有匹配使用,程序也不会出问题--但建议:匹配使用
            #include<srtdbg.h>
            _crtdumpMemoryLeak()函数:检测是否存在内存泄漏
        2.自定义类型出问题:1.内存泄漏  2.程序崩溃

    展开全文
  • C++ 空间申请new delete

    千次阅读 2019-03-05 17:03:16
    new申请空间 new 的类型 一定要和赋值匹配上 如结构体: #include &lt;iostream&gt; using namespace std; int main() { int *p1 = new int; *p1 = 22; cout &lt;&lt; *p1 &lt;...

    new:申请空间

    new 的类型  一定要和赋值匹配上

    如结构体:

     

    #include <iostream>
    using namespace std;
    
    int main()
    {
    	int *p1 = new int;
    	*p1 = 22;
    	cout << *p1 << endl;
    
    	delete p1;
    	system("pause");
    	return 0;
    
    
    }

    注:

    int *p1 = new int;

    *p1 = 22;

    和 下面一样

    int *p1 = new int(22);

    申请数组空间

    #include <iostream>
    using namespace std;
    
    int main()
    {
    	int *p = new int[3];//申请长度为3的数组空间(存int类型)
    	p[0] = 12;
    	p[1] = 20;
    	p[2] = 30;
    
    
    	cout << p[0] << endl;
    
    	delete[] p;//数组要在delete后面加【】
    	system("pause");
    	return 0;
    
    
    }

    赋值可以用memset()

    int类型 4字节

    #include <iostream>
    using namespace std;
    
    int main()
    {
    	int *p = new int[3];//申请长度为3的数组空间(存int类型)
    	memset(p, 0, 3 * 4);//int4字节  3*4  全赋值为0
    
    
    	cout << p[0] << endl;
    
    	delete[] p;//数组要在delete后面加【】
    	system("pause");
    	return 0;
    
    
    }

    附加:*的使用

    1.在声明指针时

    2.在指针的读、写时

    #include <iostream>
    using namespace std;
    
    int main()
    {	//声明*变量时
    	int a = 12;
    	int *p = &a;
    
    	//读、写
    	cout << *p << endl;
    	*p = 123;
    	cout << a << endl;
    
    	
    	system("pause");
    	return 0;
    
    
    }

     

     

     

     

    展开全文
  • C++ 从堆区申请空间 new和delete

    千次阅读 2020-03-19 21:48:15
    当我们创建数组的时候,总是需要提前预定数组的长度,然后编译器分配预定长度 的数组空间,在使用数组的时,会有这样的问题,数组也许空间太大了,浪费空 间,也许空间不足,所以对于数组来讲,如果能根据需要来分配...

    在这里插入图片描述

    努力的意义,不是让你取得多大的成就,而是让你在平凡的日子里,活得比原来的那个自己更好一点。

    1、和malloc calloc realloc比较

    当我们创建数组的时候,总是需要提前预定数组的长度,然后编译器分配预定长度 的数组空间,在使用数组的时,会有这样的问题,数组也许空间太大了,浪费空 间,也许空间不足,所以对于数组来讲,如果能根据需要来分配空间大小再好不 过。 所以动态的意思意味着不确定性。 为了解决这个普遍的编程问题,在运行中 可以创建和销毁对象是最基本的要求。当然c早就提供了动态内存分配(dynamic memoryallocation),函数malloc和free可以在运行时从堆中分配存储单元。 然 而这些函数在c++中不能很好的运行,因为它不能帮我们完成对象的初始化工作。
    1.1、malloc返回一个void指针,c++不允许将void赋值给其他任何指针,必须强转。
    1.2、malloc可能申请内存失败,所以必须判断返回值来确保内存分配成功。
    1.3、malloc 不会调用构造函数。free 不会调用析构函数(重要的)

    当创建一个c++对象时会发生两件事:

    1. 为对象分配内存
    2. 调用构造函数来初始化那块内存 第一步我们能保证实现,需要我们确保第二 步一定能发生。c++强迫我们这么做是因为使用未初始化的对象是程序出错的 一个重要原因。4.3.9.2C动态分配内存方法 为了在运行时动态分配内存,c 在他的标准库中提供了一些函数,malloc以及它的变种calloc和realloc,释放内 存的free,这些函数是有效的、但是原始的,需要程序员理解和小心使用。为 了使用c的动态内存分配函数在堆上创建一个类的实例,我们必须这样做:
    lass Person
    { 
    public: 
    	Person()
    	{ 
    		mAge = 20; 
    		pName = (char*)malloc(strlen("john")+1); 
    		strcpy(pName, "john"); 
    	} 
    	void Init()
    	{ 
    		mAge = 20;
    		pName = (char*)malloc(strlen("john")+1); 
    		strcpy(pName, "john"); 
    	} 
    	void Clean()
    	{ 
    		if (pName != NULL)
    		{ 
    			free(pName);
    		}
    	} 
    public: 
    	int mAge; 
    	char* pName; 
    };
    int main()
    {
    	//分 配 内 存 
    	Person* person = (Person*)malloc(sizeof(Person)); 
    	if(person == NULL)
    	{ 
    		return 0; 
    	}
     	// 调 用 初 始 化 函 数 
     	person->Init(); // 清 理 对 象 
    	person->Clean(); // 释 放 person 对 象 
     	free(person);
    	return EXIT_SUCCESS;
    }
    

    问题:
    1)程序员必须确定对象的长度。
    2)malloc返回一个void指 针 , c++ 不允许将 void 赋值给其他任何指针,必须强转。
    3)malloc可能申请内存失败,所以必须判 断返回值来确保内存分配成功。
    4)用户在使用对象之前必须记住对他初始化,构 造函数不能显示调用初始化(构造函数是由编译器调用),用户有可能忘记调用初始 化函数。
    c 的动态内存分配函数太复杂,容易令人混淆,是不可接受的,c++中我们推荐使用 运算符new和delete。

    2、new 给基本类型申请空间

    C ++中解决动态内存分配的方案是把创建一个对象所需要的操作都结合在一个称为new的运算符里。当用new创建一个对象时,它就在堆里为对象分配内存并调用构 造函数完成初始化。

    Person* person = new Person; 
    相当于: 
    Person* person = (Person*)malloc(sizeof(Person)); 
    	if(person == NULL)
    	{ 
    	return 0; 
    	} 
    person->Init(); //构造函数
    

    New操作符能确定在调用构造函数初始化之前内存分配是成功的,所有不用显式 确定调用是否成功。 现在我们发现在堆里创建对象的过程变得简单了,只需要一个简单的表达式,它带有内置的长度计算、类型转换和安全检查。这样在堆创建一 个对象和在栈里创建对象一样简单。

    void test01()
    {
        //基本类型
        int *p = NULL;
        //p = (int *)calloc(1,sizeof(int));
        //p = new int(100);// *p = 100
        p = new int;
        *p = 100;
        cout<<"*p = "<<*p<<endl;//100
        //释放 free(p)
        delete p;
    }
    

    3、new 申请 基本类型数组空间(案例)

    在这里插入图片描述
    在这里插入图片描述

    注意:

    new 没有加[] delete释放的时候 就不加[]
    new 加[] delete释放的时候 就加[]

    4、new delete 给类对象申请空间

    无参
    void test04()
    {
        data *p = new data;
    
        delete p;
    }
    

    在这里插入图片描述
    有参

    void test05()
    {
        data *p = new data{"lucy",18};
    
        p->showdata();
        delete p;
    }
    
    

    在这里插入图片描述

    对象数组

    本质是数组 只是数组的每个元素是类的对象

    void test06()
    {
    	//对象数组 ob是数组每个元素是data类型的对象
    	//定义对象数组的时候 系统会自动给 数组中的每个元素 调用构造函数
    	//调用无参构造函数
        data ob[5];
    }
    

    运行结果:
    在这里插入图片描述

    如果想让对象数组中的元素调用有参构造 必须人为使用 有参构造初始化。

    void test07()
    {
        //对象数组 arr1是数组 每个元素是Person类型的对象
        //定义对象数组的时候 系统会自动给 数组中的每个元素 调用构造函数
        //人为 为元素 调用有参构造
        //初始化部分 调用有参构造 为初始化部分自动调用默认构造(无参构造)
        data arr1[5]={ data("lucy",18), data("bob",20)};
        //arr1[0] 第0个元素 就是Person的对象
        arr1[0].showdata();
        arr1[1].showdata();
    }
    

    运行结果:

    用new delete申请 对象数组

    在这里插入图片描述

    尽量不要用delete释放void *

    在这里插入图片描述

    注意:没有析构?为什么?

    delete发现p1指向的类型 为void 无法从void中寻找响应析构函数
    在这里插入图片描述

    注意:malloc、free和new、delete 不可以混搭使用

    展开全文
  • c++中对new申请的内存释放方式有delete和delect[]两种方式,那么这两种方式具体该怎么理解呢? 我们都知道,在c++中用new分配内存,用delect释放内存;使用new[]分配内存,就用delete[]释放内存。具体来讲就是...
  • 当我们需要创建一个矩阵的时候, 可以使用二级指针, 在内存中申请一块空间。 mat = new int*[row_len] ; for(int i=0 ; i<row_len ; i++){ mat[i] = new int [col_len] ; } 观察上面的代码: 首先给二...
  • C++ 使用new申请内存

    2020-10-28 16:33:28
    new 是C++语言中用来动态申请内存的关键字,返回的是申请到的内存单元的地址。使用方式为: 指针变量名 = new 要存储数据的类型 e.g. int*add = new int ; *add = 121; # 或者直接赋值 int*add = new int(121); ...
  • new申请内存失败了乍办

    千次阅读 2019-07-04 15:30:42
    1.标准C++ 里,如果 new 分配内存失败,默认是抛出异常的。 首先按c++标准的话,new失败会抛出bad_alloc异常 try { double *ptr=new double[1000000]; } catch(bad_alloc &memExp) { //失败以后,要么abort...
  • 1、在使用C++语言编写程序时,建议使用new和delete两个运算符,new和delete不是系统函数,因此使用new和delete的代码比使用malloc和free工作效率更高2、new运算符的语法标准格式: 指针 = new 数据类型;...
  • 在C++中我们新建一个指针对象,之后使用new在栈中申请一片内存空间,并调用对象的构造函数(基本对象类型无构造函数) 简单的动态分配内存方式如下: double *pvalue; //此时vs会提示无法读取内存 if (!(pvalue = ...
  • 使用new申请内存时,初始化为零

    千次阅读 2020-01-02 00:08:22
    在c++中经常使用new操作符来申请一块堆内存,然后通过一些初始化内存的函数比如memset、RtlZeroMemory等,将这块申请的堆内存初始化为零。 其实new关键字支持申请内存时就自动初始化为零,如下所示: wsk = new ...
  • LINUX能new最大空间是多少?

    千次阅读 2018-10-25 14:50:33
    new最大空间大小 = 操作系统剩余内存大小 + 操作系统剩余交换分区大小 ...2、new申请的超出最大空间(剩余内存大小 + 剩余交换分区大小)后,才会报出异常且得到一个空指针。 3、int64_t nSize = 1024 * 10...
  • C++ new[] 实际申请内存

    千次阅读 2017-06-04 22:08:29
    c++ 中使用new动态生成数组时,实际申请内存是否与期望值一样?如下面代码所示new int[count]申请内存是否等于len? const int count = 10; const int len = sizeof(int) * count; int *array = new int[count]; ...
  • 1.什么是new和delete 在C语言中我们可以利用标准库函数中的 malloc 和 free 来动态分配内存空间,而在C++中提供了运算符 new 和 delete 来取代 malloc 和 free 进行动态分配内存空间。... //申请内存空间。 n...
  • malloc函数是C语言中stdlib.h头文件下用于申请动态内存的函数,其返回类型是申请的同变量类型的指针,其基本用法如下: typename *p=(typename*)malloc(sizeof(typename)); 以申请一个int型变量和一个结点型node...
  • 二、new创建类对象实例 1、new创建类对象例子: CTest* pTest = new CTest();//pTest指针指向的该对象的入口地址 delete pTest; pTest用来接收类对象指针。 不用new,直接使用类定义申明: CTest mTest; 此种创建...
  • new用来动态分配内存,如果分配成功,则返回一个指向该分配空间的指针,如果此空间不可用或分配空间失败或检测到某些错误,则返回零或空指针。所以应在动态分配操作结束后,首先检查返回的地址值是否为零,以确认...
  • 动态申请内存new和malloc的区别

    千次阅读 2015-03-15 20:52:42
    文章转自... new和malloc的区别 1. malloc()函数 1.1 malloc的全称是memory allocation,中文叫动态内存分配。 原型:extern void *malloc(unsigned int num_bytes);
  • 判断用new申请内存是否成功

    万次阅读 2014-07-04 10:24:23
    char* p=NULL;//最好初始化为NULL p = new char[nSize]; if(p == NULL) exit(); .... delete[] p; p = NULL; //删除后马上赋值为NULL
  • 但是一来不方便,二来显得很low,三来有的情况会出错,比如当类A或结构体A中存在string类型变量时,对malloc申请的指针内的string类变量无法赋值,所以对A类型的指针空间就不能使用malloc来申请。之前在...
  •  代码:   #include&lt;iostream&gt; using namespace std; int main(int argc, char** argv) {  int n=3,m=3; ... //动态申请二维数组 n行 m列  array = new int*[n];  fo...
  • 动态内存申请(malloc, calloc, new)之分配虚拟内存空间和物理内存空间 1. 动态内存申请的底层系统调用 动态内存申请函数根据申请的内存大小选择不同的系统调用,小于128K选择brk系统调用分配内存,大于128K选择...
  • 在C语言中 我们必须使用malloc函数,因为C语言没有new这个操作符,但是如果你的编译器是C++的话,是可以使用new的. C语言的malloc函数的使用方法: 1.首先定义一个long指针,像这样long* pNumber; 2.动态开辟一片内存...
  • 有以下几种方法: 1、 char (*p)[4] = new char[100][4]; p[1][2] = a; ... delete [] p; 2、 char **p = new char*[100]; for(i=0;i p[i] = new char[4];
  • C++ new 的三种面貌

    千次阅读 2015-05-05 00:19:17
    1.new的三种面貌C++中使用new来产生一个存在于heap(堆)上对象时,实际上是调用了operator new()函数和placement new()函数。在使用new创建堆对象时,我们要清楚认清楚new的三种面貌,分别是: (1)new operator...
  • 关于C++中用New申请创建动态数组

    千次阅读 多人点赞 2018-04-04 13:10:03
    (一)定义一个整数 int *p=new int; //申请一个int类型大小的空间地址给p ... //申请空间的同时赋初值3 (二)定义一个一维数组 int *p=new int[SIZE]; int *p=new int[10]{1,2,3,4,5,6,7,8,9,10}; ...
  • 当我们的程序在运行时才能决定数组空间的大小的情况下,我们会经常使用new或者malloc来在堆空间中动态的申请一片空间,这是相当的方便和实用的。最近经常使用自己也发现了一些问题以及自己对这些问题的思考: void ...
  • C++ new申请二维动态数组详解

    千次阅读 2020-12-01 21:02:59
    C++ new申请二维动态数组详解 new关键字 new关键字用于申请一段动态内存空间,位于堆上,在程序运行过程中才执行。可以用来创新数组和实例化对象。 如图所示:用new申请一维动态数组,大小为5。 int *arrayPtr=new ...
  • 如何为二维数组用new申请内存

    千次阅读 2018-07-12 14:56:13
    要学会怎么为二维数组分配内存首先要知道二维数据的结构。 二维数组是很多个一维数组按行排列起来的数组,所以要创建二维数组我们...int **c=new *[3]; for(int i=0;i;i++) { c[i]=new int[3]; } 忽然感觉越讲越复杂。
  • // HelloWorld.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include using namespace std; int _tmain(int argc, _TCHAR* argv[]) ... int *p=new int; *p=20; cout*p; delete p;//delete

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 163,513
精华内容 65,405
关键字:

new申请空间