C语言 动态数组实现

一、概述

C语言是不能直接定义动态数组的，数组必须在初始化时确定长度。

如果要在程序运行时才确定数组的长度，就需要在运行的时候，自己去向系统申请一块内存用动态内存分配实现动态数组。

二、动态内存分配函数

1、malloc()函数

void *malloc(unsigned int size)

分配size个字节的内存空间，返回地址的指针，如果内存不够分，就返回空指针NULL。 注意：返回的指针是没有类型的，所以要使用得强制类型转换。

2、calloc()函数

void *calloc(unsigned int num, unsigned int size)

这个也是申请动态内存空间，不过就是分开了而已。 一共申请num个长度为size字节的内存空间。

3、free()函数

void free(void *p)

释放指针p内存空间。

这个很重要！！！！很重要！！！重要！！！

4、realloc()函数

void *realloc(void *p, unsigned int size)

给指针p申请的存储空间改为size个字节，返回的是存储空间首地址（指针）

三、动态数组实现

1、一维动动数组实现

dynamicArrayOneDimensional.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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

/**************************************************
dynamicArrayOneDimensional.c
输入N个数，求平均数
**************************************************/
main()
{
  int *p = NULL, n, i, sum;
  printf("Please enter array size:");
  scanf("%d", &n);

  /* 申请地址n个长度为sizeof(int)的连续存储空间 */
  p = (int *)malloc(n * sizeof(int));

  if(p == NULL)
  {
      printf("No enough memory!\n");
      exit(0);
  }

  printf("Please enter the score:");
  for(i = 0; i<n; i++)
  {
      scanf("%d", p+i);
  }

  sum = 0;
  for(i = 0; i<n; i++)
  {
      sum = sum + *(p + i);
  }

  printf("aver = %d\n", sum/n);
  free(p);

}

2、二维动态数组的实现

dynamicArrayTwoDimensional.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

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

int findMax(int *p, int m, int n, int *pRow, int *pCol);

int main()
{
  int *pScore = NULL, i, j, m, n, maxSocre, row, col;

  printf("Please enter array size m,n:");
  scanf("%d, %d", &m, &n);

  pScore = (int *) calloc(m*n, sizeof(int));
  if(pScore == NULL)
  {
      printf("No enough memory!\n");
      exit(0);
  }

  printf("Please enter the score:\n");
  for (i = 0; i < m; i++)
  {
      for (j = 0; j < n; j++)
      {
          scanf("%d", &pScore[i*n+j]);
      }
  }

  maxSocre = findMax(pScore, m, n, &row, &col);

  printf("maxSocre = %d, class = %d, number = %d\n", maxSocre, row+1, col+1);

  free(pScore);

  return 0;
}

int findMax(int *p, int m, int n, int *pRow, int *pCol)
{
  int i, j, max;

  max = p[0];
  *pRow = 0;
  *pCol = 0;
  for (i = 0; i < m; i++)
  {
      for (j = 0; j < n; j++)
      {
          if (p[i*n+j] > max)
          {
              max = p[i*n+j];
              *pRow = i;
              *pCol = j;
          }
      }
  }

  return (max);
}
时间： 2024-10-08 04:20:12

C语言 动态数组实现的相关文章

线性表之顺序存储结构（C语言动态数组实现）

线性表的定义:N个数据元素的有限序列 线性表从存储结构上分为:顺序存储结构(数组)和 链式存储结构(链表) 顺序存储结构:是用一段连续的内存空间存储表中的数据 L=(a1,a2,a3....an) 链式存储结构:是用一段一段连续的内存空间存储表中每一行的数据,段与段之间通过一个引用(指针)相互连接来,形成一个链式的存储结构 看到顺序存储结构的图示,我们可能会马上联想到C语言的数组.是的,数组就是一种典型的顺序存储数据结构.下面我通过一个实例,来实现对顺序存储结构中的数据增.删.改.查的操作. 首

C语言动态数组空间分配问题

**动态数组起源:** 在实际的编程中,往往会发生这种情况,即所需的内存空间取决于实际输入的数据,而无法预先确定.对于这种问题,用静态数组的办法很难解决.为了解决上述问题,C语言提供了一些内存管理函数,这些内存管理函数结合指针可以按需要动态地分配内存空间,来构建动态数组,也可把不再使用的空间回收待用,为有效地利用内存资源提供了手段.动态数组的内存空间是从堆(heap)上分配(即动态分配)的.是通过执行代码而为其分配存储空间.当程序执行到这些语句时,才为其分配.程序员自己负责释放内存.对内存的动态

(2)redis的基本数据结构是动态数组

redis的基本数据结构是动态数组 一.c语言动态数组 先看下一般的动态数组结构 struct MyData { int nLen; char data[0]; }; 这是个广泛使用的常见技巧,常用来构成缓冲区.比起指针,用空数组有这样的优势: 1.不需要初始化,数组名直接就是所在的偏移   2.不占任何空间,指针需要占用int长度空间,空数组不占任何空间.  这个数组不占用任何内存,意味着这样的结构节省空间: 该数组的内存地址就和他后面的元素的地址相同,意味着无需初始化,数组名就是后面元素的地

[转]C语言构建动态数组完整实例

原文地址:http://www.jb51.net/article/52153.htm 本文以一个完整的实例代码简述了C语言构建动态数组的方法,供大家参考,完整实例如下: ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #include <stdio.h> #include <malloc.h> int main(void) {     int len;     int * arr;     printf("请输入数组长度:&q

《C语言中动态数组的创建及引用》

C语言中动态数组的创建及引用 动态数组是相对于静态数组而言的,静态数组的长度是预定义好的,在整个程序中,一旦给定了数组大小后就无法改变,,而动态数组则不然,它可以根据程序需要重新指定数组的大小.动态数组的内存空间是由堆动态分配的,通过执行代码为其分配储存空间,只有程序执行到分配语句时,才为其分配储存空间. 对于动态数组,其创建比静态数组更麻烦一些,使用完必须由程序员自己释放,否则将引起内存泄漏,但是其使用非常灵活,能根据程序需要动态分配大小,因此相对于静态数组来说,使用动态数组的自由度更大. 对

C语言实现使用动态数组实现循环队列

我在上一篇博客<C语言实现使用静态数组实现循环队列>中实现了使用静态数组来模拟队列的操作.由于数组的大小已经被指定,无法动态的扩展.所以在这篇博客中,我换成动态数组来实现.动态数组可以不断开辟内存空间,只是会在数组的初始化时有所不同,其他对数组的操作都是一样的.代码上传至 https://github.com/chenyufeng1991/Queue_DynamicArray . (1)声明变量 static int *queue;//声明数组 static int maxSize;//数组大

C#语言中的动态数组（ArrayList）模拟常用页面置换算法（FIFO、LRU、Optimal）

目录 00 简介 01 算法概述 02 公用方法 03 先进先出置换算法(FIFO) 04 最近最久未使用(LRU)算法 05 最佳置换算法(OPT) 00 简介 页面置换算法主要是记录内存的忙闲状态,为进程分配和释放内存.当主存的空间太小而无法装入所有的进程时,就需要在内存和硬盘之间进行调度操作. 多数操作系统只采用某种特定的页面置换算法进行置换,无法预先探测当前运行进程的页面访问模式,因此不能根据不同的页面访问模式,选用不同的页面置换算法.当然,如果能对不同的访问模式选取相应的页面置换算法,

C语言中怎么求动态数组大小

先来个简单的例子 int a[] = {1,2,3}; int arr_len = 0; arr_len = sizeof(a)/sizeof(int); 解释:sizeof() 关键字是求出对象所占用的内存空间的大小,so, sizeof(a)是算出整个数组占用的空间的大小. 因为是整数数组,一个整数在32位系统上占用4个字节,不同的系统数值可能不同, 用sizeof(int)可以计算出 一个整数占用的内存空间大小.所以用sizeof(a)/sizeof(int)数组中有几个整数,也即算出了数

c语言，动态数组

试着直接malloc一个2*3*4的空间来模拟数组: #include <stdio.h> #include <malloc.h> int main(void) { int*** pArr = NULL; pArr = (int ***)malloc(2*3*4*sizeof(int)); if(pArr == 0) { return -1; } memset(pArr, 0, 2*3*4*sizeof(int)); pArr[0][0][1] = 11; printf("