精华内容
下载资源
问答
  • 用于c动态分配数组的列表库。 例子: // appending elements to the list and printing # include # include " list/list.h " int main () { struct list list; set (&list); // sets the startup options for ...
  • c动态分配 数组指针

    2010-08-03 14:31:00
    //分配地址空间,指针指向起始地址 for(i=0;i;i++) { array[i]=i+1; printf("array[%d]=%d/n",i,array[i]); } free(array); //释放地址空间 array=NULL; //使指针重新指向null,以免悬挂 ...

     


    please input the length of the array:
    5
    array[0]=1
    array[1]=2
    array[2]=3
    array[3]=4
    array[4]=5

    展开全文
  • 以下是在堆上创建2D数组(或动态分配2D数组)的不同方法。在以下示例中,我们将“r”视为行数,将“c”视为列数,并创建了一个二维数组,其中r = 3,c = 4,并遵循以下值 1 2 3 4 5 6 7 8 9 10 11 121.使用单个指针:...

    以下是在堆上创建2D数组(或动态分配2D数组)的不同方法。

    5b3de1c233dfc3dbfaaba5dc7e3c486e.png

    在以下示例中,我们将“ r ”视为行数,将“ c ”视为列数,并创建了一个二维数组,其中r = 3,c = 4,并遵循以下值

      1 2 3 4
    5 6 7 8
    9 10 11 12

    1.使用单个指针:
    一种简单的方法是使用简单的指针算法分配大小为r * c的存储块和访问元素。

    #include 
    #include
    int main()
    {
    int r = 3, c = 4;
    int *arr = (int *)malloc(r * c * sizeof(int));
    int i, j, count = 0;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    *(arr + i*c + j) = ++count;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    printf("%d ", *(arr + i*c + j));
    return 0;
    }

    输出:

    1 2 3 4 5 6 7 8 9 10 11 12

    2.使用指针数组
    我们可以创建大小为r的指针数组。请注意,从C99开始,C语言允许使用可变大小的数组。创建指针数组后,我们可以为每行动态分配内存。

    #include 
    #include
    int main()
    {
    int r = 3, c = 4, i, j, count;
    int *arr[r];
    for (i=0; i arr[i] = (int *)malloc(c * sizeof(int));
    count = 0;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    arr[i][j] = ++count;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    printf("%d ", arr[i][j]);
    return 0;
    }

    输出:

    1 2 3 4 5 6 7 8 9 10 11 12

    3.使用指向指针的指针
    我们还可以使用双指针动态创建指针数组。一旦我们动态分配了数组指针,就可以像方法2一样为每行动态分配内存。

    include 
    #include
    int main()
    {
    int r = 3, c = 4, i, j, count;
    int **arr = (int **)malloc(r * sizeof(int *));
    for (i=0; i arr[i] = (int *)malloc(c * sizeof(int));
    count = 0;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    arr[i][j] = ++count;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    printf("%d ", arr[i][j]);
    return 0;
    }

    输出:

    1 2 3 4 5 6 7 8 9 10 11 12

    4.使用双指针和一个malloc调用

    #include
    #include
    int main()
    {
    int r=3, c=4, len=0;
    int *ptr, **arr;
    int count = 0,i,j;
    len = sizeof(int *) * r + sizeof(int) * c * r;
    arr = (int **)malloc(len);
    ptr = (int *)(arr + r);
    for(i = 0; i < r; i++)
    arr[i] = (ptr + c * i);
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    arr[i][j] = ++count;
    for (i = 0; i < r; i++)
    for (j = 0; j < c; j++)
    printf("%d ", arr[i][j]);
    return 0;
    }

    输出:

    1 2 3 4 5 6 7 8 9 10 11 12
    展开全文
  • C 语言动态分配数组

    2013-10-04 10:34:00
    如何动态的定义及使用数组呢?记得一般用数组的时候都是先指定大小的。当时问老师,老师说是不可以的。后来又问了一位教C++的老师,他告诉我在C++里用new可以做到,一直不用C++,所以也不明白。今天在逛论坛时终于...
    如何动态的定义及使用数组呢?记得一般用数组的时候都是先指定大小的。当时问老师,老师说是不可以的。后来又问了一位教C++的老师,他告诉我在C++里用new可以做到,一直不用C++,所以也不明白。今天在逛论坛时终于找到了C语言中的用法(看原贴):

        int *a;
        int N;
        scanf("%d", &N);
        a = (int *) malloc(N * sizeof(int));
        ....
        free(a);

        这样就动态分配了数组a[N]。数组的长度N可输入确定,也可用程序中的变量确定。但要注意程序结束后要用free()将其释放,否则内存会泄漏。
    #include <stdio.h>
    #include <stdlib.h>
    int main()
    {
        int i = 0;

        int *a;
        int N;

        printf("Input array length: ");
        scanf("%d", &N);
        printf("\n");

        a = (int *) malloc(N * sizeof(int));//int 可以用*a来代替
        
        for(i = 0; i < N; i++)
        {
            a[i] = i + 1;

            printf("%-5d", a[i]);
            if ((i + 1) % 10 == 0)
                printf("\n");
        }

        free(a);

        printf("\n");    
        return 0;
    }
    这样就完成了数组a[N]的动态分配,那么多维怎么分配呢?一个道理啊!!!!!!!!!!!!

     二维

    #include <stdlib.h>

    #include<stdio.h>

    int main()

    {

    int nrows,ncolumns;

    scanf("%d,%d",nrows,ncolumns);

    区别的地方 
    //为数组分配行数      注意指针多了个* 
    int **array = malloc(nrows * sizeof(*array));//注意分配的是整形指针的数量 每行元素是个整形指针

    /*这里可以写成

    int **array;

    array=(int**)malloc(nrows*sizeof(int*));//这里int可以写成**array

    */

    //对每行分配数组个数(就是二维数组的列数)
     for(i = 0; i < nrows; i++)
     {

    /*

    这里int*可以写成*array 其实array是一个指向指针的指针变量,所以要将分配的内存转化为指针类型,在一台计算机中所有的指针变量分配的内存大小相同都是计算机的位数(就是地址线的条数,指针变量存放的是地址与地址线对应可以寻址)

    */

    array[i] = (int*)malloc(ncolumns * sizeof(int));

    for(l=0;l<ncolumns;l++)

    {

    array[i][l]=...

    }

     }

    //付初值以及处理过程

    free(array);

    return 0;

    }
    多维一个道理 每增加一维 输入数据就要多一个  定义指针的时候就多一个*  且分配的时候也要多个* 还要多个for循环 

    三维

    #include<stdlib.h>

    #include<stdio.h>

    int main()

    {

    int rows,colnums,num;

    scanf("%d %d %d",rows,colnums,num);

    int ***p=malloc(rows*sizeof(*p));

    /*

    这里可以写成

    int ***p;

    p=(int***)malloc(rows*sizeof(int**));//int**可以写成*p

    */

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

    {

    p[i]=(int**)malloc(colnums*sizeof(int*));//**p

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

     {

      p[i][j]=(int*)malloc(num*sizeof(int));//这里可以写成*p

    for(r=0;r<num;r++)

    {

    p[i][j][r]=...

    }

     }

    }

    free(p);

    return 0;

    }

    以上扩展内容纯熟个人总结(水平不高) 如果有哪里不对希望高手帮忙指出,谢谢

    展开全文
  • 1. c语言中动态分配和释放在c中,申请动态内存是使用malloc和free,这两个函数是c的标准库函数,分配内存使用的是系统调用,使用它们必须包含stdlib.h,才能编译通过。malloc后需要检查内存是否分配成功,free则要在...

    1. c语言中动态分配和释放

    在c中,申请动态内存是使用malloc和free,这两个函数是c的标准库函数,分配内存使用的是系统调用,使用它们必须包含stdlib.h,才能编译通过。

    malloc后需要检查内存是否分配成功,free则要在指针不为空的情况下才能进行。

    示例代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    int main()
    {
     char *p = (char*)malloc(10);
     if ( p == NULL)
     {
      printf("errorn");
     }
     strncpy(p, "23456", sizeof(p)-1);
     printf("p=%sn", p);
     if ( p != NULL)
     {
      free(p);
      p = NULL;
     }
     return 0;
    }

    2. c++动态分配和释放

    c++中,申请动态内存是使用new和delete,这两个关键字实际上是运算符,并不是函数。

    需要注意的是:new的不是数组的话,则直接delete就好,并且只会调用一次析构函数,而new[]的话,则需使用delete[]来释放,并且数组中每一个元素都会调用一次析构函数,调用完析构函数再释放内存。

    3. new/delete的底层实现

    对于基本数据类型(无需构造函数)而言new是重载了new运算符,调用了operator new,复杂数据类型则在此基础上还会调用构造函数,而operator new里面则是调用的malloc函数,如果调用malloc失败,则直接抛出异常;

    对于基本数据类型(无需析构函数)而言delete是重载了delete运算符,调用了operator delete,复杂数据类型则在此基础上还会调用析构函数,而operator delete里面则是调用的free函数。

    4. new[]/delete[]的底层实现

    • 简单数据类型(包括基本数据类型和不需要析构函数的类型) 对于简单数据类型而言,new[]调用的是operator new[],计算出数组总大小之后调用operator new。值得一提的是,可以通过()初始化数组为零值,实例:
    char* p = new char[32]();
    

    等同于:

    char *p = new char[32];
    memset(p,0, 32);
    

    简单数据类型时delete[]则和delete一样,没区别。

    • 复杂数据类型 对于复杂数据类型而言new[]先调用operator new[]分配内存,然后在指针的前四个字节写入数组大小,最后看分配了多少个元素就调用多少次构造函数,之所以要在前4个字节写入数组大小,是因为释放内存之前会调用每个对象的析构函数。但是编译器并不知道p实际所指对象的大小。如果没有储存数组大小,编译器就不知道应该调用几次析构函数;

    new[]分配的内存只能由delete[]释放,如果由delete释放会崩溃,为什么会崩溃呢?

    假设指针p指向new[]分配的内存,因为要4字节存储数组大小,实际分配的内存地址为[p-4],系统记录的也是这个地址,delete[]实际释放的就是p-4指向的内存,而delete会直接释放p指向的内存,这个内存根本没有被系统记录,所以会崩溃。

    5. c++中new失败了怎么办

    根据前面new实现原理说的,C++里,如果new分配内存失败,默认是抛出异常的。所以,如果分配成功,p == NULL就绝对不会成立;而如果分配失败了,也不会执行 if ( p == NULL ),因为分配失败时,new 就会抛出异常跳过后面的代码。如果你想检查 new 是否成功,应该捕捉异常:

    try {
           int* p = new int[SIZE];
          // 其它代码
    } catch ( const bad_alloc& e ) {
          return -1;
    }
    

    当然,标准 C++ 亦提供了一个方法来抑制 new 抛出异常,而返回空指针,如下:

    int* p = new (std::nothrow) int; // 这样如果 new 失败了,就不会抛出异常,而是返回空指针
    if ( p == NULL ) // 像这样,这个判断就有意义了
    return -1;
    

    6. delete失败时是什么现象,一般是因为什么原因

    delete失败可能是因为内存在之前已经delete过一次了,再次delete就会失败,linux下报错:double free or corruption,已放弃。

    7. placement new的使用

    placement new用于在已经分配好的内存上,再进行二次分配,具体实现如下:

    //假设有类X,成员函数Do(),代码如下:
    
    int main()
    
    {
    
        char *buf = new char[sizeof(X)];
    
        X *x = new (buf) X;
    
        x->Do();
    
        x->~X(); //一定要主动调用析构函数去析构
    
        delete []buf;
    
        return 0;
    
    }
    

    ff6bb4b743c0486a6954729adf76e0fa.png
    展开全文
  • C语言是通过动态分配内存解决动态数组的。但是java中我们初始化数组必须要指定数组长度或者是指定数组的值。 这个时候有一种做法就是给数组分配一个很大的长度的数组空间,显然这样做是类似于C的解决之道。其实还有...
  • //new 动态分配存放一个整数的存储空间,并将其首地址符给指针变量 p 使用 new 可数组动态分配内存空间 ,这时需要在类型名后面缀上数组大小 new 可在为简单变量分配内存的同时,进行初始化。 使用 new 动态分配...
  • 关于线性表的定义和相信大家已经很熟悉了,...然后我们来看一下顺序表的代码描述,我们用结构体来表示一个顺序表,其中数组data里边存的是顺序表的元素,length表示表示顺序表的长度。这样我们就可以定义一个顺...
  • —****** 1******—要实现什么函数呢?...先列出来:要用动态分配的内存的方式,来存放数组元素,且需要一个指针成员变量重载赋值 = 运算符重载括号 [] 运算符重载复制构造函数实现 push_back 和 ...
  • 动态分配数组实现bmp图片翻转、缩小、灰白处理 目录实验要求:出现的问题源码1.main.cpp2.function.cpp3.function.h4.struct.h 实验要求: 1.动态分配二维数组a,将图像数据“降维”后读入a中。 这里的“降维”指的...
  • 01 实现自定义的可变长数组类型假设我们要实现一个会自动扩展的数组,要实现什么函数呢?先从下面的main函数给出的实现,看看有什么函数是需要我们实现的。int main(){ MyArray a; // 初始化的数组是空的 for(int i ...
  • 1 引言对于计算机程序处理而言,对内存的管理就像是对一片雷区的管理,管理的好,可以杀死一片一片的bug,管理的不好,将使你自己抓狂,程序...2 内存分配方式内存分配方式有三种:(1)从静态存储区域分配。内...
  • 01 实现自定义的可变长数组类型假设我们要实现一个会自动扩展的数组,要实现什么函数呢?先从下面的main函数给出的实现,看看有什么函数是需要我们实现的。int main(){ MyArray a; // 初始化的数组是空的 for(int i ...
  • 以下是在堆上创建2D数组(或动态分配2D数组)的不同方法。在以下示例中,我们将“r”视为行数,将“c”视为列数,并创建了一个二维数组,其中r = 3,c = 4,并遵循以下值 1 2 3 4 5 6 7 8 9 10 11 121.使用单个指针:...
  • C对象有4种存储期:静态存储期、线程存储期、自动存储期、动态分配存储期。如果对象具有静态存储期,那么它在程序的执行期间一直存在。文件作用域变量具有静态存储期。注意,对于文件作用域变量,关键字static表明了...
  • 相信很多同学在初学C语言时候,都会遇到遇到一个问题:指针,永远的神!好消息,这个痛点将会在这篇文章得到解决,...然后是三大基本结构顺序循环分支,随后的内容几乎都是对数据类型的扩充结构体 指针 链表 数组...
  • 以前我们先接触到数组,知道这是一种静态分配的方式,在程序执行前需要多少存储单元都是要提前规划好的,使用过程中需要再分配或者对多余内存进行回收是不方便的。接着我们引入了动态存储分配,这种方式正好和静态...
  • 我们都知道要实现根据程序的需要动态分配存储空间,在C中需要使用到stdlib.h中的两个函数,malloc,free,两个函数的介绍如下: malloc函数的原型为: void *malloc (u igned int size) 其作用是在内存的动态...
  • color:#3c3c3c; background-color:#d2c39b; font-size:16px;}.sysFunc{color:#627cf6;font-style:italic;font-weight:bold;} .selfFuc{color:#800080;} .bool{color:#d2576f;} .condition{colo...
  • 我们都知道要实现根据程序的需要动态分配存储空间,在C中需要使用到stdlib.h中的两个函数,malloc,free,两个函数的介绍如下: malloc函数的原型为: void *malloc (u igned int size) 其作用是在内存的动态存储区...
  • // 动态分配二维数组存储像素数据,注意先申请一个存放指针的数组, data = (unsigned char **)malloc(sizeof(unsigned char*) * this->height); //其大小为sizeof(unsigned char*) * bitmapinfoheader.biHeight...

空空如也

空空如也

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

c动态分配数组