精华内容
下载资源
问答
  • C++动态内存分配方法

    2013-07-29 14:15:00
    C++动态内存分配方法 #include <stdio.h> #include <string.h> #include <stdlib.h> char* upcase(char *inputstring); ...

    C++动态内存分配方法

    #include <stdio.h> #include <string.h> #include <stdlib.h>

    char* upcase(char *inputstring);                                                                                                                int main(void){     char *str1;     str1 = upcase("hello");     printf("str1=%s \n",str1);     free(str1);     return 0; }

    char* upcase(char *inputstring) {     char *newstring;     int counter;

        if(!(newstring=malloc(strlen(inputstring)+5)))     {           printf("Error malloc !\n");         exit(1);     }  

        strcpy(newstring,inputstring);     for(counter =0; counter < strlen(newstring); counter++){         if(newstring[counter] >= 97 && newstring[counter] <=122)         {               newstring[counter] -= 32;         }       }  

        return newstring;

    }

    转载于:https://www.cnblogs.com/vdtte/p/3222843.html

    展开全文
  • int main() { //分配内存 Person* person = (Person*)malloc(sizeof(Person)); if (person == NULL) { return 0; } //调用初始化函数 person->Init(); //清理对象 person->Clean(); //释放person对象 free(person);...
    #define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    using namespace std;
    class Person
    {
    public:
    	Person()
    	{
    		m_Age = 20;
    		m_Name = (char*)malloc(strlen("灵狐姐姐") + 1);
    		strcpy(m_Name, "灵狐姐姐");
    	}
    	void Init()
    	{
    		m_Age = 20;
    		m_Name = (char*)malloc(strlen("灵狐姐姐") + 1);
    		strcpy(m_Name, "灵狐姐姐");
    	}
    	void Clean()
    	{
    		if (m_Name != NULL)
    		{
    			free(m_Name);
    		}
    	}
    public:
    	int m_Age;
    	char* m_Name;
    
    };
    int main()
    {
    	//分配内存
    	Person* person = (Person*)malloc(sizeof(Person));
    	if (person == NULL)
    	{
    		return 0;
    	}
    	//调用初始化函数
    	person->Init();
    	//清理对象
    	person->Clean();
    	//释放person对象
    	free(person);
    
    	return EXIT_SUCCESS;
    
    }
    
    #define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    using namespace std;
    class Person 
    {
    public:
    	Person() 
    	{
    
    		cout << "无参构造函数!" << endl;
    		pName = (char*)malloc(strlen("undefined") + 1);
    		strcpy(pName, "undefined");
    		mAge = 0;
    	}
    	Person(char* name, int age) 
    	{
    		cout << "有参构造函数!" << endl;
    		pName = (char*)malloc(strlen(name) + 1);
    		strcpy(pName, name);
    		mAge = age;
    	}
    	void ShowPerson() 
    	{
    		cout << "Name:" << pName << " Age:" << mAge << endl;
    	}
    	~Person() 
    	{
    		cout << "析构函数!" << endl;
    		if (pName != NULL) {
    			delete pName;
    			pName = NULL;
    		}
    	}
    public:
    	char* pName;
    	int mAge;
    };
    
    void test01() 
    {
    	Person* person1 = new Person;
    	Person* person2 = new Person("John", 33);
    
    	person1->ShowPerson();
    	person2->ShowPerson();
    
    	delete person1;
    	delete person2;
    }
    
    
    
    
    
    
    
    
    
    int main()
    {
    	test01();
    	system("pause");
    	return EXIT_SUCCESS;
    }
    

    delete只能适用于由new创建的对象

    展开全文
  • new运算符在堆(内存)中创建一个由类型名指定类型的对象,如果创建成功,返回对象的地址,否则返回NULL; 初始表给出被创建对象的初始值; 由于返回的是地址,所以要事先定义一个类型相同的指针变量来存储这个...

    【本篇博文为学习过程中做的笔记,方便自己阅读而已,非原创】

     

    1.new运算创建对象

    基本语法:        指针变量  =  new  类型名    (初始化表);

    • new 运算符在堆(内存)中创建一个由类型名指定类型的对象,如果创建成功,返回对象的地址,否则返回NULL;
    • 初始表给出被创建对象的初始值;
    • 由于返回的是地址,所以要事先定义一个类型相同的指针变量来存储这个地址;

    例:

    int * ip;

    ip = new int(5);

    或:int *p = new int(5);

     

    • 创建一维数组

    语法格式:                指针变量   =  new 类型名[下标表达式];

    • 下标表达式可以是变量表达式
    • new申请失败时返回NULL,申请动态数组往往需要较大的空间,因此在程序中需要对new的返回值进行判断,看是否申请成功

    例:

    int *pa;

    pa = new int[5];

    或:int *pa = new int[5];

    • 创建多维数组

    语法形式:      指针变量  = new 类型名T[下标表达式1][下标表达式2][...]

    • 只有下标表达式1可以是任意正整数的表达式,其他必须为值为正整数的常数表达式;
    • 如果申请成功,new 运算返回一个指向新分配内存首地址的指针,它是一个T类型数组的指针而不是T类型指针数组元素的个数为除最左边一维(最高维)外各维下标表达式的乘积

    例:

    int (*pb)[4][5];

    pb = new int[3][4][5];

     

    2.delete运算

    • 释放指针变量           delete 指针变量名;

    • 释放动态数组          delete [ ]指针变量名;

    3.实例:

    建立m*n的动态二维矩阵:

    #include<iostream>
    using namespace std;
    int mian()
    {
        int m,n;
        int **dm;
        cout << "input matrix size m,n:" ;
        cin >> m >> n;
        dm = new int *[m];
        for(int i = 0; i < m; i++)
            if((dm[i] = new int [n])==NULL)
                exit(0);
        for(int i = 0; i< m; i++)
            for(int j = 0; j < n; j++)
                cin >> dm[i][j];
        for(int i = 0; i < m; i++)
        {
            for(int j = 0; j < n; j++)
                cout << dm[i][j];
            cout << endl;
         }
        for(int i = 0; i < m; i++)
            delete []dm[i];
        delete dm;

     

    展开全文
  • 转载自http://blog.csdn.net/lavorange/article/details/42879605 一、二维数据的内存空间动态分配 方法一: void malloc2D_1(int **&a) { a = new int*[xDim]; for(int i=0;i;i++) a[i] = new i

    转载自http://blog.csdn.net/lavorange/article/details/42879605

    一、二维数据的内存空间动态分配

    方法一:

    void malloc2D_1(int **&a)  
    {  
        a = new int*[xDim];  
        for(int i=0;i<xDim;i++)       
            a[i] = new int[yDim];  
        assert(a!=NULL);  
    }  
      
    int main()  
    {  
        int **arr = NULL;  
        malloc2D_1(arr);  
    }  

    首先arr是一个二级指针,为arr分配xDim空间,每一维都是一个指向数组的指针,且每个数组内部的地址空间是连续的,但是数组之间的地址空间没有连续性。

    这种分配方法在内存中的布局如下:


    方法二:

    void malloc2D_2(int **&a)   
    {  
        a = (int **)malloc( xDim * sizeof(int *) );  
        a[0] = (int *)malloc( xDim * yDim * sizeof(int) );  
        for(int i=1;i<xDim;i++)  
        {  
            a[i] = a[i-1] + yDim;          
        }  
        assert(a!=NULL);  
    }  
      
    int main()  
    {  
        int **arr = NULL;  
        malloc2D_2(arr);  
    }  
    这种方法相当于动态分配了一个一维的连续的空间,然后让相应的数组指针指向某些固定的位置达到调用的目的。

    这种分配方法在内存中的布局如下:



    二、二维数据的内存空间释放

    对于第一种分配方式需要一个一个释放,对第二种方式只要分配两个指针即可。

    void free2D_1(int **a)  
    {  
        for(int i=0;i<xDim;i++)           
            free(a[i]);  
    }  
      
    void free2D_2(int **a)  
    {  
        free(a[0]);  
        free(a);  
    }  
    三、完整代码

    #include<iostream>  
      
    using namespace std;  
      
    const int xDim = 10;  
    const int yDim = 8;  
      
    //分配空间方式一   
    void malloc2D_1(int **&a)  
    {  
        a = new int*[xDim];  
        for(int i=0;i<xDim;i++)       
            a[i] = new int[yDim];  
        assert(a!=NULL);  
    }  
    //分配空间方式二   
    void malloc2D_2(int **&a)   
    {  
        a = (int **)malloc( xDim * sizeof(int *) );  
        a[0] = (int *)malloc( xDim * yDim * sizeof(int) );  
        for(int i=1;i<xDim;i++)  
        {  
            a[i] = a[i-1] + yDim;          
        }  
        assert(a!=NULL);  
    }  
      
    void assign_value(int **a,int val)  
    {  
        for(int i=0;i<xDim;i++)       
        {  
            for(int j=0;j<yDim;j++)          
            {  
                a[i][j] = val;     
                cout<<a[i][j]<<" ";       
            }  
            cout<<endl;  
        }  
        cout<<endl;  
    }  
    //释放空间方式一   
    void free2D_1(int **a)  
    {  
        for(int i=0;i<xDim;i++)           
            free(a[i]);  
    }  
    //释放空间方式二   
    void free2D_2(int **a)  
    {  
        free(a[0]);  
        free(a);  
    }  
      
    int main()  
    {  
        int **arr1 = NULL;  
        int **arr2 = NULL;  
          
        malloc2D_1(arr1);  
        malloc2D_2(arr2);  
          
        assign_value(arr1,1);  
        assign_value(arr2,2);  
          
        free2D_1(arr1);  
        free2D_2(arr2);  
          
        system("pause");  
        return 0;  
    }  




    展开全文
  • C语言实现内存管理,实现malloc() ,free(), 但不会不会像标准库的动态内存分配函数容易引起内存崩溃。
  • 动态内存分配

    2021-04-03 08:44:18
    C++ 有静态内存分配和动态内存分配两种方式。静态分配是通过声明变量实现的。如: int i,j,k; float scores[100]; 如果程序使用的数据量很大而且可变时,利用动态内存分配可以有效地利用内存空间。更特殊的情况下,...
  • 摘要:目前,嵌入式Linux的动态内存分配依然采用原有的Lea分配器,无法满足一些嵌入式环境下应用程序对内存分配的速度和效率上的要求,因此对动态内存分配进行优化具有重要的研究价值.本论文分析了通用内存分配器中一些...
  • 关于动态内存分配

    2020-11-02 23:28:15
    为什么存在动态内存分配? 我们之前掌握的内存开辟方式是在栈区开辟的: int val = 20;...动态内存分配不需要像数组等静态内存分配方法那样预先的分配存储空间,而是由系统根据程序的需要即时分配,且分配的
  • 首先,在使用动态分配内存技术前,必须明白自己在做什么,这样做与其它的方法有什么不同,特别是会产生哪些负面影响,天下没有免费的午餐。动态分配内存与静态分配内存的区别...3) 动态内存分配需要指针或引用数据类型
  • C++动态内存分配

    2017-05-29 08:43:10
    所谓动态内存分配就是在程序执行过程中动态地分配或回收存储空间的内存分配方法动态内存分配由系统根据程序的需要即时分配内存,与之相对的静态内存分配是编译器在程序执行前为程序中的各种变量分配好存储空间。 ...
  • 所谓动态内存分配就是指在程序执行的过程中动态地分配或者回收存储空间的...动态内存分配不象数组等静态内存分配方法那样需要预先分配存储空间,而是由系统根据程序的需要即时分配,且分配的大小就是程序要求的大小。
  • 掌握动态内存分配方法。 编程输入学生人数n及某门课成绩,计算并输出其平均分的整数部分(请用malloc和free进行动态内存分配)。 input: 5 90 80 70 60 50 output: 70 #include &lt;iostream&gt; #include...
  • 在类继承中使用动态内存分配需要有一定的技巧,其中包括在基类中使用动态内存分配,在继承类中使用动态内存分配以及在继承类中使用动态内存分配,程序代码演示了这三种情况下的使用方法
  • C 动态内存分配

    2020-02-07 18:08:09
    动态内存分配 1. 概念 程序运行时临时分配存储区的方法 2. 优点 临时决定需要分配的存储区数量 生命周期自己决定 以前讲声明变量,在变量生命周期开始的时候,计算机为变量分配存储区,生命周期结束的时候,...
  • 内存动态分配

    2020-11-30 19:48:57
    要求使用动态内存分配方法为这n个整数分配空间。 Input 输入包含两行 第一行,一个整数n(0<n<=1000) 第二行,n个整数 Output n个整数逆序后的结果 Sample Input 3 1 2 3 Sample Output 3 2 1 #include<...
  • 动态内存分配的C代码示例

    千次阅读 2016-09-02 20:58:05
    之前有同学在QQ上问我,C语言中的动态内存分配是怎么回事。首先,我们来看看内存分配的概念,它是指在程序执行的...一般说来,内存分配方法分为静态内存分配和动态内存分配两种。在本文中,我们主要讨论动态内存分配
  • 来点干货本文是利用Java实现操作系统中的四种动态内存分配方式 ,分别是:BFNFWFFF分两部分,第一部分是介绍四种分配方式的概念以及例子,第二部分是代码实现以及讲解。四种分配方式概念操作系统中有一个动态分区...
  • 动态内存分配不像数组等静态内存分配方法那样需要预先分配存储空间,而是由系统根据程序的需要即时分配,且分配的大小就是程序要求的大小。 动态内存分配较静态内存分配有以下两个特点: (1)不需要预先分配存储...
  • C/C++动态内存分配

    2016-08-23 18:48:07
    动态内存分配不象数组等静态内存分配方法那样需要预先分配存储空间,而是由系统根据程序的需要即时分配,且分配的大小就是程序要求的大小。 C中和C++中对于动态内存的创建和删除都是有些不同的。下面先说C中如何...
  • C语言--动态内存分配

    2018-05-12 18:12:32
    动态内存分配动态内存分配(Dynamic Memory Allocation)就是指在程序执行的过程中动态地分配或者回收存储空间的分配内存的方法。 2)为什么要进行动态内存分配? (1)传统数组(即静态内存分配)有着如下缺...
  • C++ 继承与动态内存分配 一、问题导入 (1)继承是怎样与动态内存分配(即使用new与delete)进行互动的呢? (2)假如基类使用动态内存分配,并重新定义赋值和复制构造函数,这将怎样影响派生类的实现呢?取决于派生...
  • 主要介绍了C语言动态内存分配的详解的相关资料,这里提供了实现方法整理和出现错误的解决办法,需要的朋友可以参考下
  • C语言动态内存分配

    2017-03-13 21:09:00
    C语言动态内存分配C语言分配内存大小的一些方法 malloc(内存大小),用来分配一个固定的内存大小 realloc(需要扩容的首地址,分配的内存大小),用来进行内存重新分配(内存不够用了,就在原来的内存地址上去扩容) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,494
精华内容 1,797
关键字:

动态内存分配方法