c语言数组

前面我们学习了函数 现在来看数组

目录

一数组

1.1 概述

1.2定义格式

1.3数组的初始化

1.4 访问数组元素

1.5 获取数组长度

1.6数组名

二多维数组

2.1概述

2.2初始化二维数组

2.3访问二维数组元素

三传递数组给函数

3.1 形式参数是一个指针

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

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

四从函数返回数组

五指向数组的指针

六静态数组和动态数组

6.1概述：

6.2 静态数组

6.3 动态数组

---

一数组

1.1 概述

：数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。

简单来说：数组由数据类型相同的一系列元素组成 即开辟一块内存空间 给数组 数组每相邻的元素不仅逻辑上相邻物理地址上也是相邻的

由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素

1.2定义格式

type arrayName [ arraySize ];

这叫做一维数组。arraySize 必须是一个大于零的整数常量，type 可以是任意有效的 C 数据类型

arraysize：指的是数组里面有多少个元素 比如 有五个元素 arraysize=5

（思考一下 既然有一维数组 有没有多维数组呢？）

示例：

int a[5];

定义了一个一维数组 类型是int 数组名字是a 数组有五个元素 

1.3数组的初始化

概述：在 C 中，可以逐个初始化数组，也可以使用一个初始化语句

示例：统一进行初始化

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

在{}里面进行初始化 每个元素赋值结束 中间用逗号隔开

逐个初始化（）涉及到数组元素的访问 等下就会提到 

    a[0]=1;//数组的首个元素下标是从0开始的
    a[1]=2;
    a[2]=3;

补充：如果省略掉了数组的大小，数组的大小则为初始化时元素的个数

即：我们来验证一下对不对 初始化的时候 忽略了数组的大小 但是我们进行了正确的赋值

来输出一下数组的个数，看下是否等于3

#include<stdio.h>
int main()
{
    int a[]={1,2,3};
    printf("size=%ld\n",sizeof(a)/sizeof(int));
    return 0;      
}

语句sizeof(a):求a数组的大小 ，sizeof （int）数组每一个元素的大小 所以相除一个是数组的元素个数

1.4 访问数组元素

数组元素可以通过数组名称加索引进行访问。元素的索引（又叫元素的下标）是放在方括号内，跟在数组名称的后边

元素的下标：是从0开始的 比如 int a[size]; 首元素是a[0],尾元素是a[size-1]

我们来看一下示例：
 

#include <stdio.h>
 
int main ()
{
   int n[ 10 ]; /* n 是一个包含 10 个整数的数组 */
   int i,j;
 
   /* 初始化数组元素 */         
   for ( i = 0; i < 10; i++ )
   {
      n[ i ] = i + 100; /* 设置元素 i 为 i + 100 */
   }
   
   /* 输出数组中每个元素的值 */
   for (j = 0; j < 10; j++ )
   {
      printf("Element[%d] = %d\n", j, n[j] );
   }
 
   return 0;
}

使用了上述的三个概念，即，声明数组、数组赋值、访问数组 大家自敲一下 看一下运行结果

1.5 获取数组长度

在上面有简单的说明如何获取数组长度 即利用sizeof函数来实现

代码：其中 a是数组名 int是数组类型  len即为数组a的长度

#include<stdio.h>
int main()
{
    int a[]={1,2,3};
    int len;
    len=sizeof(a)/sizeof(int);
    printf("len=%d\n",len);
    return 0;      
}

1.6数组名

概述：数组名 上面我们已经提及了 那为什么这里还要开一个小节呢?因为数组名 还有其他的用处

大家回忆一下我们上节说的函数名的特点 函数名是函数的首地址 那数组名呢?

在 C 语言中，数组名表示数组的地址，即数组首元素的地址。当我们在声明和定义一个数组时，该数组名就代表着该数组的地址

可以看到数组名表示数组的首地址和函数名是不是异曲同工

当然了既然是地址肯定是和指针相关的 这里有基础的往下看 没基础的先记住 学完指针再回来观看

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

int myArray[5] = {10, 20, 30, 40, 50};
int *ptr = &myArray; // 或者直接写作 int *ptr = myArray[0];

2 虽然数组名表示数组的地址，但在大多数情况下，数组名会自动转换为指向数组首元素的指针。这意味着我们可以直接将数组名用于指针运算

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", arr[i]); // 数组名arr被当作指针使用
    }
}

int main() {
    int myArray[5] = {10, 20, 30, 40, 50};
    printArray(myArray, 5); // 将数组名传递给函数
    return 0;
}

补充：大家有没有想过 我们说数组名是数组的首地址 但是我们在求数组的长度的时候

是sizeof（数组名）那为什么呢？为什么这里数组名可以代表整个数组呢？

实际上：这是种特殊情况 在c语言中 有俩种情况 数组名代表数组整体 其他情况都是代表数组的首地址

1 在sizeof的时候 用sizeof求数组的长度 我们只需要把数组名传进去就好 此时数组名代表整个数组

2 在加&数组名 此时数组名也代表整个数组

数组简单定义就到这了 我们来通过题目来熟悉一下

输出数组的长度和数组的每一个元素

代码：

#include<stdio.h>
int main()
{
    int a[]={1,2,3};
    int len;
    len=sizeof(a)/sizeof(int);
    printf("len=%d\n",len);
    for(int i=0;i<len;i++)
    {
       printf("a[i]=%d\n",a[i]);
    }
    return 0;      
}

运行结果：

输入5个整数，并存入数组，计算输出数组中值为奇数的元素的平均值

代码很简单 我就不注释了 

#include<stdio.h>
int main()
{
    int a[5]={1,2,3,4,5};
    int len,num=0;
    double avge =0;
    len=sizeof(a)/sizeof(int);
    printf("len=%d\n",len);
    for(int i=0;i<len;i++)
    {
        if(a[i]%2!=0)
        {
            avge+=a[i];
            num++;
        }
    }
    printf("奇数的个数=%d\n",num);
    printf("平均数=%f\n",avge/num);
    return 0;      
}

代码2：输出数组的最大值

#include<stdio.h>
int max (int a[],int len)
{   
    for(int i=0;i<len;i++)
    {
        if(a[i]>a[i+1])
        {
            a[i+1]=a[i];
        }
    }
    return a[len-1];
}
int main()
{
    int a[]={1,2,3,4,5};
    int len=0;
    len = sizeof(a)/sizeof(int);
    printf("max=%d\n",max(a,len));
    return 0;      
}

在学习了基础的一维数组 我们来看多维数组

二多维数组

我们常用的是二维数组 ，下面我们介绍的多为二维数组

2.1概述

：一个二维数组，在本质上，是一个一维数组的列表。声明一个 x 行 y 列的二维整型数组

基本格式：

type arrayName [ x ][ y ];

type 可以是任意有效的 C 数据类型，arrayName 是一个有效的 C 标识符（数组的名字）。一个二维数组可以被认为是一个带有 x 行和 y 列的表格

我们来看一下示例：

int x[3][4];//定义一个int类型的二维数组 名为x 三行四列

因此，数组中的每个元素是使用形式为 a[ i , j ] 的元素名称来标识的，其中 a 是数组名称，i 和 j 是唯一标识 a 中每个元素的下标

2.2初始化二维数组

多维数组可以通过在括号内为每行指定值来进行初始化。下面是一个带有 3 行 4 列的数组

示例1：

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

示例2：内部嵌套的括号是可选的，下面的初始化与上面是等同的

默认从第0行开始 

int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

2.3访问二维数组元素

概述：二维数组中的元素是通过使用下标（即数组的行索引和列索引）来访问的

示例：为什么我们要说索引呢？因为和一维数组一样 二维数组 也是从0开始的

int val=a[3][4]//获取数组中第 3 行第 4 个元素

我们来看一道示例：输出二维数组的每个元素 大家自己运行一下

#include <stdio.h>
 
int main ()
{
   /* 一个带有 5 行 2 列的数组 */
   int a[5][2] = { {0,0}, {1,2}, {2,4}, {3,6},{4,8}};
   int i, j;
 
   /* 输出数组中每个元素的值 */
   for ( i = 0; i < 5; i++ )
   {
      for ( j = 0; j < 2; j++ )
      {
         printf("a[%d][%d] = %d\n", i,j, a[i][j] );
      }
   }
   return 0;
}

三传递数组给函数

概述：将数组作为函数的参数去使用

有三种方法 我们来一一学习 这三种声明方式的结果是一样的，因为每种方式都会告诉编译器将要接收一个整型指针

3.1 形式参数是一个指针

可以在后面中学习到有关指针的知识，有基础的可以先看 

void myFunction(int *param)
{
.
.
.
}

示例：假设数组为一维数组 而元素为2 返回最大值

代码：

#include<stdio.h>
int max(int *param)
{
    for(int i=0;i<2;i++)
    {
        if(*param>*(param+1))
        {
            *param=*(param+1);
        }
    }
    return *(param+1);
}
int main()
{
    int n[2]={1,2};
    printf("flag=%d\n",max(n));
    return 0;      
}

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

示例：

void myFunction(int param[10])
{
.
.
.
}

示例：求数组最大值

#include<stdio.h>
int max(int a[10],int len)
{
    for(int i=0;i<len;i++)
    {
        if(a[i]>a[i+1])
        {
            a[i+1]=a[i];
        }
    }
    return a[len-1];
}
int main()
{
    int n[10]={1,2,2,4,5,9,22,6,9,11};
    int len;
    len=sizeof(n)/sizeof(n[0]);
    printf("max=%d\n",max(n,len));
    return 0;      
}

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

示例：

void myFunction(int param[])
{
.
.
.
}

示例：求平均值

#include <stdio.h>
 
/* 函数声明 */
double getAverage(int arr[], int size);
 
int main ()
{
   /* 带有 5 个元素的整型数组 */
   int balance[5] = {1000, 2, 3, 17, 50};
   double avg;
 
   /* 传递一个指向数组的指针作为参数 */
   avg = getAverage( balance, 5 ) ;
 
   /* 输出返回值 */
   printf( "平均值是： %f ", avg );
    
   return 0;
}
 
double getAverage(int arr[], int size)
{
  int    i;
  double avg;
  double sum=0;
 
  for (i = 0; i < size; ++i)
  {
    sum += arr[i];
  }
 
  avg = sum / size;
 
  return avg;
}

运行结果大家自己敲一下

四从函数返回数组

概述：C 语言不允许返回一个完整的数组作为函数的参数。但是，您可以通过指定不带索引的数组名来返回一个指向数组的指针 （有基础的观看 涉及指针内容）

基本格式：

int * myFunction()
{
.
.
.
}

补充：C 不支持在函数外返回局部变量的地址，除非定义局部变量为 static 变量

大家想一下为什么？前面我们提及过

示例：

#include <stdio.h>
int *avge(int a)/*定义一个指针类型的函数这样返回值也是指针*/
{
    static int avge[5];//用static修饰 把变量的作用域更改 防止函数结束 自动销毁局部变量的
    avge[0]=a;
    for(int i=1;i<5;i++)
    {
       avge[i]=i+1;
    }
    return avge;
}
int main ()
{
    int *p=NULL;//定义一个指针 用来接收数组的首地址
    p=avge(1);
    for(int i=0;i<5;i++)
    {
        printf("%d\n",*(p+i));
    }
   return 0;
}

五指向数组的指针

有基础的观看

概述：前面我们说过 数组名就是数组的首地址，组名本身是一个常量指针 即意味着它的值是不能被改变的，一旦确定，就不能再指向其他地方

double balance[50];

balance 是一个指向 &balance[0] 的指针，即数组 balance 的第一个元素的地址

既然数组名是常量指针，那我们怎么定义一个指针来指向数组呢 ？

示例：

double *p;
double balance[10];

p = balance;

使用数组名作为常量指针是合法的，反之亦然。因此，*(balance + 4) 是一种访问 balance[4] 数据的合法方式。

一旦把第一个元素的地址存储在 p 中，就可以使用 *p、*(p+1)、*(p+2) 等来访问数组元素

*(p+1)：数组的第二个元素

那是因为什么呢？我们说过指针是地址 可以+1就访问下一个元素 是和数组的一个特征有关

数组在物理地址上是连续的一块内存地址

我们来看一下示例：

#include <stdio.h>
 
int main ()
{
   /* 带有 5 个元素的整型数组 */
   double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};
   double *p;
   int i;
 
   p = balance;
 
   /* 输出数组中每个元素的值 */
   printf( "使用指针的数组值\n");
   for ( i = 0; i < 5; i++ )
   {
       printf("*(p + %d) : %f\n",  i, *(p + i) );
   }
 
   printf( "使用 balance 作为地址的数组值\n");
   for ( i = 0; i < 5; i++ )
   {
       printf("*(balance + %d) : %f\n",  i, *(balance + i) );
   }
 
   return 0;
}

运行结果：

六静态数组和动态数组

6.1概述：

在 C 语言中，有两种类型的数组：

• 静态数组：编译时分配内存，大小固定。
• 动态数组：运行时手动分配内存，大小可变。

静态数组的生命周期与作用域相关，而动态数组的生命周期由程序员控制。

在使用动态数组时，需要注意合理地分配和释放内存，以避免内存泄漏和访问无效内存的问题

6.2 静态数组

静态数组是在编译时声明并分配内存空间的数组。

静态数组具有固定的大小，在声明数组时需要指定数组的长度。

静态数组的特点包括：

• 内存分配：在程序编译时，静态数组的内存空间就被分配好了，存储在栈上或者全局数据区。
• 大小固定：静态数组的大小在声明时确定，并且无法在运行时改变。
• 生命周期：静态数组的生命周期与其作用域相关。如果在函数内部声明静态数组，其生命周期为整个函数执行期间；如果在函数外部声明静态数组，其生命周期为整个程序的执行期间

补充：上述我们说的都是静态数组

静态数组的声明和初始化示例：

int staticArray[5]; // 静态数组声明
int staticArray[] = {1, 2, 3, 4, 5}; // 静态数组声明并初始化

对于静态数组，可以使用 sizeof 运算符来获取数组长度，例如

int array[] = {1, 2, 3, 4, 5};
int length = sizeof(array) / sizeof(array[0]);

这里我们就不用示例了 上面有很多

6.3 动态数组

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

动态数组特点如下：

• 内存分配：动态数组的内存空间在运行时通过动态内存分配函数手动分配，并存储在堆上。需要使用 malloc、calloc 等函数来申请内存，并使用 free 函数来释放内存。
• 大小可变：动态数组的大小在运行时可以根据需要进行调整。可以使用 realloc 函数来重新分配内存，并改变数组的大小。
• 生命周期：动态数组的生命周期由程序员控制。需要在使用完数组后手动释放内存，以避免内存泄漏

基本格式：类型说明符* 数组名 = (类型说明符*)malloc(数组长度*sizeof(类型说明符))

动态数组的声明、内存分配和释放实例

int size = 5;
int *dynamicArray = (int *)malloc(size * sizeof(int)); // 动态数组内存分配
// 使用动态数组
free(dynamicArray); // 动态数组内存释放

动态分配的数组，可以在动态分配内存时保存数组长度，并在需要时使用该长度

int size = 5; // 数组长度
int *array = malloc(size * sizeof(int));

// 使用数组

free(array); // 释放内存

以上代码我们使用 malloc 函数动态分配了一个整型数组，并将长度保存在变量 size 中。然后可以根据需要使用这个长度进行操作，在使用完数组后，使用 free 函数释放内存

补充：动态数组的使用需要注意内存管理的问题，确保在不再需要使用数组时释放内存，避免内存泄漏和访问无效的内存位置

示例：

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

int main() {
    int size = 5;
    int *dynamicArray = (int *)malloc(size * sizeof(int)); // 动态数组内存分配

    if (dynamicArray == NULL) {
        printf("Memory allocation failed.\n");
        return 1;
    }

    printf("Enter %d elements: ", size);
    for (int i = 0; i < size; i++) {
        scanf("%d", &dynamicArray[i]);
    }

    printf("Dynamic Array: ");
    for (int i = 0; i < size; i++) {
        printf("%d ", dynamicArray[i]);
    }
    printf("\n");

    free(dynamicArray); // 动态数组内存释放

    return 0;
}

以上实例中，我们首先声明了一个变量 size 来指定动态数组的大小。

然后使用 malloc 函数为动态数组分配内存，并通过 sizeof 运算符计算所需的内存大小。

接下来，通过循环和 scanf 函数，从用户输入中读取元素值并存储到动态数组中。

（简单介绍一下scanf 从键盘键入值 后续会提及）

最后，使用循环遍历并打印动态数组的元素。在程序结束时，使用 free 函数释放动态数组所占用的内存。

请注意，在使用动态数组时，需要检查内存分配是否成功（即 dynamicArray 是否为 NULL），以避免在内存分配失败时发生错误

到这里 我们数组就结束了 数组和指针是密切相关的 建议大家把指针学完之后 再回来重新看一下