【嵌入式——C语言】数组

【嵌入式——C语言】数组

  • 概念
  • 分类
    • 字符数组
    • 短整型数组
    • 整型数组
    • 长整型数组
    • 浮点型数组
    • 指针数组
    • 结构体数组
    • 一维数组
    • 二维数组
    • 多维数组
  • 定义
    • 一维数组
    • 二维数组
  • 初始化
    • 一维数组
    • 二维数组
  • 引用
    • 一维数组
    • 二维数组
  • 传递数组给函数
    • 方式一
    • 方式二
    • 方式三
  • 函数返回数组
  • 执行数组的指针
  • 静态数组
  • 动态数组

概念

数组可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据,但它往往被认为是一系列相同类型的变量。
所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素,最高的地址对应最后一个元素。

分类

字符数组

char s[10];

短整型数组

short int a[10];

整型数组

int a[10];

长整型数组

long int a[10];

浮点型数组

float a[10];

指针数组

char* a[10];
int* b[10];

结构体数组

struct stu boy[10];

一维数组

int a[30];

二维数组

int a[2][30];

多维数组

定义

一维数组

数据类型 数组名[数组元素个数]

int  a[10];

二维数组

数据类型 数组名[行的个数][列的个数]

int a[3][4];

初始化

定义数组的时候,顺便给数组赋初始值

一维数组

int a[5]={1,2,3,4,5};

二维数组

int a[3][4] = {  
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

引用

数组的名字就是数组的首地址,即第0个元素的地址,是个常量

一维数组

int a[5];
a[0] = 0;
a[1] = 1;
a[2] = 2;
a[3] = 3;
a[4] = 4;

二维数组

a[0][0] = 0
a[0][1] = 1
a[0][2] = 2
a[0][3] = 3
a[1][0] = 4
a[1][1] = 5
a[1][2] = 6
a[1][3] = 7
a[2][0] = 8
a[2][1] = 9
a[2][2] = 10
a[2][3] = 11

传递数组给函数

方式一

形式参数是一个指针

void myFunction(int *param)
{
}

方式二

形式参数是一个已定义大小的数组

void myFunction(int param[10])
{
}

方式三

形式参数是一个未定义大小的数组

void myFunction(int param[])
{
}

函数返回数组

C 语言不允许返回一个完整的数组作为函数的参数。但是,可以通过指定不带索引的数组名来返回一个指向数组的指针。
如果想要从函数返回一个一维数组,必须声明一个返回指针的函数

int * myFunction()
{
}

int * getRandom( )
{
  static int  r[10];
  int i;
 
  srand( (unsigned)time( NULL ) );
  for ( i = 0; i < 10; ++i)
  {
     r[i] = rand();
     printf( "r[%d] = %d\n", i, r[i]);
 
  }
  return r;
}

执行数组的指针

数组名本身是一个常量指针,意味着它的值是不能被改变的,一旦确定,就不能再指向其他地方。

double balance[50];

balance 是一个指向 &balance[0] 的指针,即数组 balance 的第一个元素的地址,把p赋值为balance的第一个元素的地址,看如下代码。

double *p;
double balance[10];

p = balance;

静态数组

静态数组是在编译时声明并分配内存空间的数组,静态数组具有固定的大小,在声明数组时需要指定数组的长度。

  1. 内存分配:在程序编译时,静态数组的内存空间就被分配好了,存储在栈上或者全局数据区;
  2. 大小固定:静态数组的大小在声明时确定,并且无法在运行时改变;
  3. 生命周期:静态数组的生命周期与其作用域相关。如果在函数内部声明静态数组,其生命周期为整个函数执行期间;如果在函数外部声明静态数组,其生命周期为整个程序的执行期间。
int staticArray[5]; // 静态数组声明
int staticArray[] = {1, 2, 3, 4, 5}; // 静态数组声明并初始化
int length = sizeof(staticArray) / sizeof(staticArray[0]); //计算静态数组的长度

动态数组

动态数组是在运行时通过动态内存分配函数(如 malloc 和 calloc)手动分配内存的数组。

  1. 内存分配:动态数组的内存空间在运行时通过动态内存分配函数手动分配,并存储在堆上。需要使用 malloc、calloc
    等函数来申请内存,并使用 free 函数来释放内存;
  2. 大小可变:动态数组的大小在运行时可以根据需要进行调整。可以使用 realloc 函数来重新分配内存,并改变数组的大小;
  3. 生命周期:动态数组的生命周期由程序员控制。需要在使用完数组后手动释放内存,以避免内存泄漏。
int size = 5;
int *dynamicArray = (int *)malloc(size * sizeof(int)); // 动态数组内存分配
// 使用动态数组
free(dynamicArray); // 动态数组内存释放

malloc 函数、calloc函数、free 函数会在后续的文章中讲解。

你可能感兴趣的:(c语言,java,开发语言,iot,嵌入式硬件,物联网)