C 数组

1. 数组

数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。
所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。
数组中的特定元素可以通过索引访问，第一个索引值为 0

1.声明数组
double balance[10];
2.初始化数组
double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
3.赋值
balance[4] = 50.0; 
4.访问数组
double salary = balance[9];
5.获取数组长度
int numbers[] = {1, 2, 3, 4, 5};
int length = sizeof(numbers) / sizeof(numbers[0]);

数组名
数组名表示数组的地址，即数组首元素的地址。
数组名本身是一个常量指针，意味着它的值是不能被改变的，一旦确定，就不能再指向其他地方。
我们可以使用&运算符来获取数组的地址

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

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

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;
}

2.多维数组

C 语言支持多维数组。

int threedim[5][10][4];

3.传递数组给函数

#形式参数是一个指针
void myFunction(int *param){}
#形式参数是一个已定义大小的数组
void myFunction(int param[10]){}
#形式参数是一个未定义大小的数组
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;
}
输出：
平均值是： 214.400000

4.函数返回数组

C 语言不允许返回一个完整的数组作为函数的参数。但是，您可以通过指定不带索引的数组名来返回一个指向数组的指针。
另外，C 不支持在函数外返回局部变量的地址，除非定义局部变量为 static 变量。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
/* 要生成和返回随机数的函数 */
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;
}
 
/* 要调用上面定义函数的主函数 */
int main ()
{
   /* 一个指向整数的指针 */
   int *p;
   int i;
 
   p = getRandom();
   for ( i = 0; i < 10; i++ )
   {
       printf( "*(p + %d) : %d\n", i, *(p + i));
   }
 
   return 0;
}

5.指向数组的指针

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

double *p;
double balance[10];

p = balance;

balance 是一个指向 &balance[0] 的指针，即数组 balance 的第一个元素的地址。
一旦您把第一个元素的地址存储在 p 中，您就可以使用 p、(p+1)、(p+2) 等来访问数组元素。*

#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;
}
输出：
使用指针的数组值
*(p + 0) : 1000.000000
*(p + 1) : 2.000000
*(p + 2) : 3.400000
*(p + 3) : 17.000000
*(p + 4) : 50.000000
使用 balance 作为地址的数组值
*(balance + 0) : 1000.000000
*(balance + 1) : 2.000000
*(balance + 2) : 3.400000
*(balance + 3) : 17.000000
*(balance + 4) : 50.000000

6.动态数组与静态数组

在 C 语言中，有两种类型的数组：
静态数组：编译时分配内存，大小固定。存储在栈上或者全局数据区。
动态数组：运行时手动分配内存，大小可变。存储在堆上。
静态数组的生命周期与作用域相关，而动态数组的生命周期由程序员控制。
在使用动态数组时，需要注意合理地分配和释放内存，以避免内存泄漏和访问无效内存的问题。
上述提到的例子，都是静态数组！
动态数组
内存分配：动态数组的内存空间在运行时通过动态内存分配函数手动分配，并存储在堆上。需要使用 malloc、calloc 等函数来申请内存，并使用 free 函数来释放内存。
大小可变：动态数组的大小在运行时可以根据需要进行调整。可以使用 realloc 函数来重新分配内存，并改变数组的大小。
生命周期：动态数组的生命周期由程序员控制。需要在使用完数组后手动释放内存，以避免内存泄漏。
动态数组的声明、内存分配和释放实例：

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 函数释放内存。

#我们首先声明了一个变量 size 来指定动态数组的大小。

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

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

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

#注：在使用动态数组时，需要检查内存分配是否成功（即 dynamicArray 是否为 NULL），以避免在内存分配失败时错误。
#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;
}