精华内容
下载资源
问答
  • 二维数组动态分配内存 C 二维数组动态分配和释放 (1)已知第二维 Code-1 char (*a)[N];//指向数组的指针 a = (char (*)[N])malloc(sizeof(char *) * m); printf("%d\n", sizeof(a));//4,指针 printf(&...

    二维数组动态分配内存

    复制代码

    C 二维数组动态分配和释放
    (1)已知第二维
    Code-1
    char (*a)[N];//指向数组的指针
    a = (char (*)[N])malloc(sizeof(char *) * m);
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//N,一维数组
    free(a); 
    (2)已知第一维
    Code-2
    char* a[M];//指针的数组
    int i;
    for(i=0; i<M; i++)
    a[i] = (char *)malloc(sizeof(char) * n);
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<M; i++)
       free(a[i]); 
    (3)已知第一维,一次分配内存(保证内存的连续性)
    Code-3
    char* a[M];//指针的数组
    int i;
    a[0] = (char *)malloc(sizeof(char) * M * n);
    for(i=1; i<M; i++)
    a[i] = a[i-1] + n;
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    free(a[0]); 
    (4)两维都未知
    Code-4
    char **a;
    int i;
    a = (char **)malloc(sizeof(char *) * m);//分配指针数组
    for(i=0; i<m; i++)
    {
    a[i] = (char *)malloc(sizeof(char) * n);//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<m; i++)
    {
    free(a[i]);
    }
    free(a); 
    (5)两维都未知,一次分配内存(保证内存的连续性)
    Code-5
    char **a;
    int i;
    a = (char **)malloc(sizeof(char *) * m);//分配指针数组
    a[0] = (char *)malloc(sizeof(char) * m * n);//一次性分配所有空间
    for(i=1; i<m; i++)
    {
    a[i] = a[i-1] + n;
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    free(a[0]);
    free(a); 
    2.C++动态分配二维数组
    (1)已知第二维
    Code-6
    char (*a)[N];//指向数组的指针
    a = new char[m][N];
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//N,一维数组
    delete[] a; 
    (2)已知第一维
    Code-7
    char* a[M];//指针的数组
    for(int i=0; i<M; i++)
       a[i] = new char[n];
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<M; i++)
       delete[] a[i]; 
    (3)已知第一维,一次分配内存(保证内存的连续性)
    Code-8
    char* a[M];//指针的数组
    a[0] = new char[M*n];
    for(int i=1; i<M; i++)
    a[i] = a[i-1] + n;
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    delete[] a[0]; 
    (4)两维都未知
    Code-9
    char **a;
    a = new char* [m];//分配指针数组
    for(int i=0; i<m; i++)
    {
    a[i] = new char[n];//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<m; i++)
    delete[] a[i];
    delete[] a; 
    (5)两维都未知,一次分配内存(保证内存的连续性)
    Code-10
    char **a;
    a = new char* [m];
    a[0] = new char[m * n];//一次性分配所有空间
    for(int i=1; i<m; i++)
    {
    a[i] = a[i-1] + n;//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    delete[] a[0];
    delete[] a; 
    多说一句:new和delete要注意配对使用,即有多少个new就有多少个delete,这样才可以避免内存泄漏!
    3.静态二维数组作为函数参数传递
    如果采用上述几种方法动态分配二维数组,那么将对应的数据类型作为函数参数就可以了。这里讨论静态二维数组作为函数参数传递,即按照以下的调用方式:
    int a[2][3];
    func(a);
    C语言中将静态二维数组作为参数传递比较麻烦,一般需要指明第二维的长度,如果不给定第二维长度,则只能先将其作为一维指针传递,然后利用二维数组的线性存储特性,在函数体内转化为对指定元素的访问。
    首先写好测试代码,以验证参数传递的正确性:
    (1)给定第二维长度
    Code-11
    void func(int a[][N])
    {
    printf("%d\n", a[1][2]);
    } 
    (2)不给定第二维长度
    Code-12
    void func(int* a)
    {
    printf("%d\n", a[1 * N + 2]);//计算元素位置
    } 
    注意:使用该函数时需要将二维数组首地址强制转换为一维指针,即func((int*)a);
    展开全文
  • 喜欢的同学记得点赞、转发、收藏哦~C语言经典100例将会以pdf和代码的形式发放到公众号欢迎关注:计算广告生态 即时查收1 题目功能:为二维数组动态分配内存描述:为二维数组动态分配内存,然后输出并释放内存2 思路...

    系列文章《C语言经典100例》持续创作中,欢迎大家的关注和支持。

    喜欢的同学记得点赞、转发、收藏哦~

    C语言经典100例将会以pdf和代码的形式发放到公众号

    欢迎关注:计算广告生态 即时查收

    1 题目

    功能:为二维数组动态分配内存

    描述:为二维数组动态分配内存,然后输出并释放内存

    29de25cc-815c-43d7-87e4-9ea3e4c1e150

    2 思路

    • 在C语言中,一维数组是通过 malloc() 函数动态分配空间来实现的,动态的二维数组也能够通过malloc()函数动态分配空间来实现。实际上,C语言中没有二维数组,至少对二维数组没有直接的支持,取而代之的是“数组的数组”,二维数组能够看成是由指向数组的指针构成的数组。
    • 对于一个二维数组p[i][j],编译器通过公式 *(*(p+i)+j) 求出数组元素的值,其中,p+i表示计算行指针;*(p+i)表示具体的行,是指针,指向该行首元素地址 *(*(p+i)+j 表示得到具体元素的地址;*(*(p+i)+j)表示得到元素的值。基于这个原理,通过分配一个指针数组,再对指针数组的每一个元素分配空间实现动态的分配二维数组

    案例中实现的步骤 1.定义二维指针

    int **p;   // 二维数组指针

    2.分配行动态空间

    p = (int **)malloc(sizeof(int *[M]));  // 指向指针的指针

    3.再为每一行的每一列进行动态分配

    *(p+i) = (int *)malloc(sizeof(int[N]));

    3 代码

    #include  #include #define M 3#define N 5/**功能:为二维数组动态分配内存描述:为二维数组动态分配内存,然后输出并释放内存**/int main(int argc, char const *argv[]) {  int **p;   // 二维数组指针 p = (int **)malloc(sizeof(int *[M]));  // 指向指针的指针 for (int i = 0; i 

    示例结果:

    $ gcc ex035.c -o demo$ ./demo给二维数组分配空间后,内存的内容是:0  1  2  3  41  2  3  4  52  3  4  5  6

    --END--

    喜欢本文的同学记得点赞、转发、收藏~

    更多内容,欢迎大家关注我们的公众号:计算广告生态

    C语言经典100例将会以pdf和代码的形式发放到公众号

    同时也带来更多系列文章以及干货!

    展开全文
  • 指针数组、数组指针、二维数组动态分配内存 2016-03-22 22:59 838人阅读 评论(0) 收藏 举报  分类: C(7) C++(12)  目录(?)[+] 1. 二维数组动态分配和释放 1. 已知第...

    指针数组、数组指针、二维数组动态分配内存

     838人阅读 评论(0) 收藏 举报
     分类:
     

    目录(?)[+]

    1. 二维数组动态分配和释放

    1. 已知第二维

    char (*a)[N];//指向数组的指针
    a = (char (*)[N])malloc(sizeof(char *) * m);
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//N,一维数组
    free(a); 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 1
    • 2
    • 3
    • 4
    • 5

    2. 已知第一维

    char* a[M];//指针的数组
    int i;
    for(i=0; i<M; i++)
    a[i] = (char *)malloc(sizeof(char) * n);
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<M; i++)
       free(a[i]); 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3.已知第一维,一次分配内存(保证内存的连续性)

    char* a[M];//指针的数组
    int i;
    a[0] = (char *)malloc(sizeof(char) * M * n);
    for(i=1; i<M; i++)
    a[i] = a[i-1] + n;
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    free(a[0]); 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    4.两维都未知

    char **a;
    int i;
    a = (char **)malloc(sizeof(char *) * m);//分配指针数组
    for(i=0; i <m; i++)
    {
    a[i] = (char *)malloc(sizeof(char) * n);//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<m; i++)
    {
    free(a[i]);
    }
    free(a); 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    5.两维都未知,一次分配内存(保证内存的连续性)

    char **a;
    int i;
    a = (char **)malloc(sizeof(char *) * m);//分配指针数组
    a[0] = (char *)malloc(sizeof(char) * m * n);//一次性分配所有空间
    for(i=1; i<m; i++)
    {
    a[i] = a[i-1] + n;
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    free(a[0]);
    free(a); 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    2.C++动态分配二维数组

    1.已知第二维

    char (*a)[N];//指向数组的指针
    a = new char[m][N];
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//N,一维数组
    delete[] a; 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 1
    • 2
    • 3
    • 4
    • 5

    2.已知第一维

    char* a[M];//指针的数组
    for(int i=0; i<M; i++)
       a[i] = new char[n];
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<M; i++)
       delete[] a[i]; 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    3.已知第一维,一次分配内存(保证内存的连续性)

    char* a[M];//指针的数组
    a[0] = new char[M*n];
    for(int i=1; i<M; i++)
    a[i] = a[i-1] + n;
    printf("%d\n", sizeof(a));//4*M,指针数组
    printf("%d\n", sizeof(a[0]));//4,指针
    delete[] a[0]; 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    4.两维都未知

    char **a;
    a = new char* [m];//分配指针数组
    for(int i=0; i<m; i++)
    {
    a[i] = new char[n];//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    for(i=0; i<m; i++)
    delete[] a[i];
    delete[] a; 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    5.两维都未知,一次分配内存(保证内存的连续性)

    char **a;
    a = new char* [m];
    a[0] = new char[m * n];//一次性分配所有空间
    for(int i=1; i<m; i++)
    {
    a[i] = a[i-1] + n;//分配每个指针所指向的数组
    }
    printf("%d\n", sizeof(a));//4,指针
    printf("%d\n", sizeof(a[0]));//4,指针
    delete[] a[0];
    delete[] a; 
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    多说一句:new和delete要注意配对使用,即有多少个new就有多少个delete,这样才可以避免内存泄漏!

    3.静态二维数组作为函数参数传递

    如果采用上述几种方法动态分配二维数组,那么将对应的数据类型作为函数参数就可以了。这里讨论静态二维数组作为函数参数传递,即按照以下的调用方式:

       int a[2][3];
       func(a);
    • 1
    • 2
    • 1
    • 2

    C语言中将静态二维数组作为参数传递比较麻烦,一般需要指明第二维的长度,如果不给定第二维长度,则只能先将其作为一维指针传递,然后利用二维数组的线性存储特性,在函数体内转化为对指定元素的访问。 
    首先写好测试代码,以验证参数传递的正确性:

    1.给定第二维长度

    void func(int a[][N])
    {
        printf("%d\n", a[1][2]);
    } 
    • 1
    • 2
    • 3
    • 4
    • 1
    • 2
    • 3
    • 4

    2.不给定第二维长度

    void func(int* a)
    {
        printf("%d\n", a[1 * N + 2]);//计算元素位置
    } 
    • 1
    • 2
    • 3
    • 4
    • 1
    • 2
    • 3
    • 4

    注意:使用该函数时需要将二维数组首地址强制转换为一维指针,即func((int*)a);

    展开全文
  • 喜欢的同学记得点赞、转发、收藏哦~C语言经典100例将会以pdf和代码的形式发放到公众号欢迎关注:计算广告生态 即时查收1 题目功能:为二维数组动态分配内存描述:为二维数组动态分配内存,然后输出并释放内存2 思路...

    系列文章《C语言经典100例》持续创作中,欢迎大家的关注和支持。

    喜欢的同学记得点赞、转发、收藏哦~

    C语言经典100例将会以pdf和代码的形式发放到公众号

    欢迎关注:计算广告生态 即时查收

    1 题目

    功能:为二维数组动态分配内存

    描述:为二维数组动态分配内存,然后输出并释放内存

    f25e325bd814a2b74c81f668cedc4965.png

    2 思路

    • 在C语言中,一维数组是通过 malloc() 函数动态分配空间来实现的,动态的二维数组也能够通过malloc()函数动态分配空间来实现。实际上,C语言中没有二维数组,至少对二维数组没有直接的支持,取而代之的是“数组的数组”,二维数组能够看成是由指向数组的指针构成的数组。
    • 对于一个二维数组p[i][j],编译器通过公式 *(*(p+i)+j) 求出数组元素的值,其中,p+i表示计算行指针;*(p+i)表示具体的行,是指针,指向该行首元素地址 *(*(p+i)+j 表示得到具体元素的地址;*(*(p+i)+j)表示得到元素的值。基于这个原理,通过分配一个指针数组,再对指针数组的每一个元素分配空间实现动态的分配二维数组

    案例中实现的步骤 1.定义二维指针

    int **p;   // 二维数组指针

    2.分配行动态空间

    p = (int **)malloc(sizeof(int *[M]));  // 指向指针的指针

    3.再为每一行的每一列进行动态分配

    *(p+i) = (int *)malloc(sizeof(int[N]));

    3 代码

    #include  #include #define M 3#define N 5/**功能:为二维数组动态分配内存描述:为二维数组动态分配内存,然后输出并释放内存**/int main(int argc, char const *argv[]) {  int **p;   // 二维数组指针 p = (int **)malloc(sizeof(int *[M]));  // 指向指针的指针 for (int i = 0; i 

    示例结果:

    $ gcc ex035.c -o demo$ ./demo给二维数组分配空间后,内存的内容是:0  1  2  3  41  2  3  4  52  3  4  5  6

    --END--

    喜欢本文的同学记得点赞、转发、收藏~

    更多内容,欢迎大家关注我们的公众号:计算广告生态

    C语言经典100例将会以pdf和代码的形式发放到公众号

    同时也带来更多系列文章以及干货!

    展开全文
  • C语言为二维数组动态分配内存的问题

    万次阅读 多人点赞 2013-09-07 22:57:22
    C语言中动态分配一位数组是很简单的,但是没有可以直接对二维数组进行动态分配的函数,因此,要相对二维数组动态分配内存,便要借助于一位数组来实现,具体如下:   假设要为一个n*m的二维数组分配动态内存   首先...
  • 在C++中为数组动态分配内存

    千次阅读 2015-06-02 18:14:00
    在C++中为数组动态分配内存的格式如下:   第一步:声明  type (p)[常量1][常量2]...[常量n]; 第二步:申请  p=new type[x][常量1][常量2]...[常量n]; 说明:先定义一个n维的数组指针,其中p是一个指针...
  • C++中一般使用new和...一、一维数组动态内存分配和释放 int *array1D;//使用一级指针声明一个一维数组 array1D = new int [m];//开辟m个整型变量 //释放 delete[] array1D; 二、二维数组动态内存分配和释放 int **a
  • //动态分配 char **a; a = new char* [m];//分配指针数组 for(int i=0; i<m; i++) a[i] = new char[n];//分配每个指针所指向的数组 //删除内存 for(i=0; i<m; i++) delete[] a[i]; delete[] a; ...
  • C语言中二维数组动态分配内存

    万次阅读 2013-09-01 13:01:49
    最近《数据结构》看到哈夫曼树的构造一部分的...这就涉及到二维数组内存的动态分配问题,先来看如何给一个普通的4行5列二维数组分配内存。 [code=c] int **p; int i; if( NULL == (p = (int **)malloc(4 * sizeof(in
  • // 输出10 } 接下来看对定义方式为double **a的如何用malloc对其动态分配内存: 1)方法1: #include #include #include using namespace std; int main(){ int row=20, colum=10; double **a; /* 为a分配row个指针...
  • 第一个参数是内存块中的元素数量(即大小为30 000的数组) . 第二个参数是一个块的大小(即数组中的一个元素) .所以你会这样称呼它:ptr = calloc(30000, sizeof(float));在您的情况下使用 calloc 存在一个瓶颈,因为...
  • 首先,我们一般需要用到数组的时候,都是直接声明,比如: 1 int array[3][3];  但是,在某些情况下,数组的维数我们是不知道的,可能是... 这时候就需要用new来动态申请数组了。我们一步一步来,申请一维数组
  • C++动态数组分配 int **arr; int m, n;//非连续分配 arr = new int*[m]; for(int i = 0; i ; i ++) arr[i] = new int[n];//连续分配内存 arr = new int*[m]; arr[0] = new int[m * n]; for(int i = 1; i

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,150
精华内容 2,860
关键字:

数组动态分配内存