精华内容
下载资源
问答
  • 调用函数用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;
    }
    

     

    展开全文
  • 请看代码: ``` class A{ private: int num; public: A(){ cout ; } ~A(){ cout ~A" ; } void show(){ ... new(mem) char('b');... A* p = new(mem) A;...那么开辟出的A类对象p的空间在哪?地址在哪
  • 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[]释放内存。具体来讲就是...

    今天重点说的是delete的一个小区别~~~

    c++中对new申请的内存释放方式有delete和delect[]两种方式,那么这两种方式具体该怎么理解呢?

            我们都知道,在c++中用new分配内存,用delect释放内存;使用new[]分配内存,就用delete[]释放内存。具体来讲就是delect释放new分配的单个对象指针指向的内存,delete[]释放new分配的对象数组指针指向的内存。


    首先给大家先介绍下new和delete的一些基础用法:

    一、new

     new 数据类型 ;                  //申请内存空间。
     new 数据类型   (初值);          //申请内存空间时,并指定该数据类型的初值。
     new 数据类型   [内存单元个数];    //申请多个内存空间。
     new 数据类型   [内存单元个数]();  //只能初始化为零
    

    二、 delete

    int* p3 = new int;
    
    delete p;       //释放空间与资源
    
    
    int* p2 = new int[10];
    
    delete []p2;   //"[]"代表长度并开辟内存
    

    接下来我们一起来看段代码,来区别今天主要的内容delete和delete[]:

    
    class Test
    {
    public:
    	Test(int a = 0) :ma(a)
    	{
    		std::cout << "Test::Test(int)" << std::endl;
    	}
    	~Test()
    	{
    		std::cout << "Test::~Test()" << std::endl;
    	}
    private:
    	int ma;
    };
    
    int main()
    {	
    	Test* p = new Test;       //第一种
    	delete p;
    
    	//Test* p = new Test[10]; //第二种
    	//delete []p;
    	return 0;
    }
    

    如果运行第一种结果会是:

    如果运行第二种结果是:

           总结:所以我们也可以看出来第一种的new和delete只调用一次构造和析构,而第二种的new和delete是调用十次,这也是我们做题时候会遇到的一个考点。  

    展开全文
  • // 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

    <span style="font-size:18px;">// HelloWorld.cpp : 定义控制台应用程序的入口点。

    //
    
    #include "stdafx.h"
    #include <iostream>
    using namespace std;
    int _tmain(int argc, _TCHAR* argv[])
    {
     int *p=new int;
     *p=20;
     cout<<*p<<endl;
     delete p;//delete是释放指针p指向的内存,而不是删除指针。执行delete后仍然可以使用指针p,但最好给他赋值为0.
     p=new int;
     *p=50;
     cout<<*p<<endl;
     delete p;
     p=0;//将指针赋值为空指针。删除空指针是可以的。
     delete p;
     //delete p;但是不能连续两次执行delete命令,因为p指向的内存已经被释放掉,不能在没赋值的情况下再次释放。
     system("pause");
     return 0;
    }
    
    
     
    </span>
    由于计算机的内存是有限的,因此可能出现计算机无法满足new运算符的要求的情况。这时候new运算符会返回0,当把0赋值给指针的时候,该指针就是一个空指针,空指针不指向任何有效值。
    展开全文
  • 当我们的程序运行时才能决定数组空间的大小的情况下,我们会经常使用new或者malloc来空间中动态的申请一片空间,这是相当的方便和实用的。最近经常使用自己也发现了一些问题以及自己对这些问题的思考: void ...
  • 关于用new申请0个空间的问题

    千次阅读 2012-10-17 15:07:26
    C++中虽然不允许定义长度为0的数组,但明确指出 动态分配长度为0的数组 是合法的,他返回的是一个合法的非0指针,这个指针与一般new返回的指针有所不同,他不能进行解引用操作(如果进行解引用操作,那么结果是...
  • 动态内存申请(malloc, calloc, new)之分配虚拟内存空间和物理内存空间 1. 动态内存申请的底层系统调用 动态内存申请函数根据申请的内存大小选择不同的系统调用,小于128K选择brk系统调用分配内存,大于128K选择...
  • 二、new创建类对象实例 1、new创建类对象例子: CTest* pTest = new CTest();//pTest指针指向的该对象的入口地址 delete pTest; pTest用来接收类对象指针。 不用new,直接使用类定义申明: CTest mTest; 此种创建...
  • 但是一来不方便,二来显得很low,三来有的情况会出错,比如当类A或结构体A中存在string类型变量时,对malloc申请的指针内的string类变量无法赋值,所以对A类型的指针空间就不能使用malloc来申请。之前...
  • C中,使用malloc 和calloc申请测内存空间需要使用free进行内存释放,而c++中,new函数申请空间必须使用delete来释放。一. 使用new和delete运算符时PF率的变化情况Ctrl+Alt+Del进入任务管理器、性能,运行下列...
  • 关于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和delete的实现原理 开始谈之前我们应该了解另一个概念“operator new”和“operator delete”: new操作符调用一个函数来完毕必需的内存分配,你可以重写或重载这个函数来改变它的行为。new...
  • new来分配栈上的空间

    千次阅读 2017-04-18 20:41:52
    首先传入了T1类型的一个指针。...的意思是从p地址开始new空间构造T1对象,因为p地址是栈上,所以当离开p的函数作用域,new出来的空间就自动解析掉了。相当于用new在栈上分配了空间。看着像杂技哈。
  • 1. 动态申请空间1.1 基本内容 Ⅰ 动态申请的空间没有具体名称,只能通过指针间接访问(无论new还是malloc方式)。  Ⅱ 动态申请空间都是存放堆中,有别于系统自动分配的空间是存放堆栈中(即栈)。  Ⅲ 栈中...
  • C++中不要大量用new申请小变量

    千次阅读 2007-10-13 18:53:00
    C++中不要大量用new申请小变量write by DKink|棼紫 C运行时库或者MFC提供的内存管理器不是为小内存块设计的。new操作会为一个小内存块申请操作申请一片超过自身大小很多的空间,从而浪费了内存。做个试验,写如下...
  • 动态申请存储空间

    千次阅读 2018-10-29 21:28:14
    “动态存储空间”是指程序运行期间,根据用户输入的信息决定分配空间的大小。需要对单元进行释放,分别用new 和delete 申请和释放空间。 ... 圆括号中的初值表示申请成功后,在空间中存放的初始...
  • C/C++动态申请空间

    千次阅读 2016-08-15 17:33:54
    C语言中用malloc/free; C++里用new/delete;1:C语言动态申请一维数组:#include #include int main() { int i=0; int m=9; int *p = (int*)malloc(sizeof(int)*m); for(;i; ++i) {
  • 使用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 和 delete

    万次阅读 多人点赞 2017-09-05 00:07:28
    1.什么是new和deleteC语言中我们可以利用标准库函数中的 malloc 和 free 来动态分配内存空间,而C++中提供了运算符 new 和 delete 来取代 malloc 和 free 进行动态分配内存空间。2.new的用法表达式- new 数据...
  • C++ 用new申请内存注意点

    千次阅读 2018-09-10 15:54:31
    char *src = new char[10]; char *psrc = src;(使用src之前,先定义一个指向src的指针,防止程序运行期间,src指针所指位置改变,将导致delete时出错) . . . delete[] psrc; psrc=NULL;...
  • 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]; ...
  • C++11中引进了这一新功能,即用new申请动态数组时可以直接初始化,形式如下: int* p = new int[cnt](); //其中cnt长度和int类型都可以自己定义。 我发现的问题是: //VC编译器中使用这两种方式都可以 int*...
  • C++new分配内存空间

    千次阅读 2016-09-03 22:07:58
    C++ 采用new申请新的存储单元,定义一个指针变量a,type是类型名,[]表示需要n个tyoe类型长度的存储单元。 a=new type; a=new type[]; 与new相对的是收回内存单元delete delete a; delete []p;[]是删除多...
  • Map m0 = new HashMap(0);// 不创建内部存储数组 m0.put("k","v");// 内部空间开辟了 1 (数组长度=1) Map m1 = new HashMap(1);// 不创建内部存储数组 m1.put("k","v");// 内部空间开辟了 1 (数组长度=1)
  • C语言--指针一般什么时候需要申请内存空间

    千次阅读 多人点赞 2019-05-28 22:18:08
    1. 指针所指向的地址需要存放数据的时候需要申请空间。 int *q;只有地址,没有内存空间。这个地址是随机地址。 (1)没有申请内存空间: int *q; *q = 1; cout<<*q<<endl; 错误! 指针变量q没有...
  • 1、指针所指向的地址需要存放数据的时候需要申请空间。 int *q;只有地址,没有内存空间。这个地址是随机地址。 (1)没有申请内存空间: int *q; *q = 1; cout 错误!指针变量q没有空间...
  • 判断用new申请内存是否成功

    千次阅读 2014-07-04 10:24:23
    char* p=NULL;//最好初始化为NULL p = new char[nSize]; if(p == NULL) exit(); .... delete[] p; p = NULL; //删除后马上赋值为NULL

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 161,094
精华内容 64,437
关键字:

new申请的空间在哪