C语言之数组

简介: C语言之数组

1.一维数组的创建和初始化

数组的创建

数组是一组相同类型元素的集合,数组就是存放一组数。数组的创建方式:


type_t  arr_name[const_n]

type_t    是指数组的元素类型

const_n 是一个常量表达式,用来指定数组的大小

//代码1
int arr[10];
//代码2
int count = 10;
//int arr2[count];//不能正常创建
//数组在创建时,[]中要给一个常量才可以,不能使用变量
//代码3
char arr3[10];
float arr4[1];
double arr5[20];


#include<stdio.h>
int main()
{
  int arr1[10];//创建一个类型为int 的数组,用来存放10个int类型的元素
  char arr2[5];//创建一个类型为char 的数组,用来存放5个char类型的元素
  int count = 10;
  //int arr3[count];//  []内是常量表达式才可以
  //VS2019 VS2022 这样的IDE(集成开发环境)  不支持C99 中的变长数组
  //gcc是可以支持的
  //C99 标准之前 数组的大小只能是常量表达式
  //C99 标准中引入了 变长数组的概念,使得数组在创建的时侯可以使用变量,但是这样的数组不能初识化
  return 0;
}

数组的初识化

数组的初识化是指,在创建数组的同时给数组的内容一些合理的初始值(初始化)

int arr[10]={1,2,3);
int arr2[]={1,2,3,4};
int arr3[5]={1,2,3,4,5};
char arr4[3]={'a',98,'c'};
char arr5[]={'a','b','c'};
char arr6[]="abcdef";


数组在创建的时候如果想不指定数组的大小就得初始化。数组的元素个数根据初始化的内容跟来确定。但是对于下面的代码要区分,内存中如何分配。

char arr1[]="abc";
//字符串 最后会默认加有'\0'
char arr2[3]={'a','b','c'};  
//只有abc 最后没有'\0'


#include<stdio.h>
int main()
{
  //数组在初始化是整体用大括号括起来,每个元素用逗号分隔开
  int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };//完全初识化
  int arr2[10] = { 1,2,3 };//不完全初始化  剩余元素默认为 0
  int arr3[10] = { 0 };//不完全初识化  10个元素全是0
  int arr4[] = { 0 };//省略数组大小,数组必须初始化,数组的大小是根据初识化的内容来确定的  这里只初始化1个,所以大小为1
  int arr5[] = { 1,2,3 };//数组大小为3
  //int arr6[];//错误写法 没有指定大小,也没有初始化
  char arr7[] = "abc";//字符串,数组大小为4,因为最后有 '\0'
  char arr8[] = { 'a','b','c' };//数组大小为3
  char arr9[] = { 'a',98,'c' };//与arr8数组相同,因为字符在存储时存放的时ASCII码值,b的ASCII码值是98
  return 0;
}

2.一维数组的使用

[ ]下标引用操作符,它其实就是数组访问的操作符。

#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  //下标          0 1 2 3 4 5 6 7 8 9 
  //数组下标是从0开始的 数组使用下标来访问的  最后一个元素下标为数组元素个数减一
  printf("%d\n", arr[5]); //6  []  下标引用操作符
  printf("%d\n", arr[0]); //1  []  下标引用操作符
  printf("%d\n", arr[3]); //4  []  下标引用操作符
  int i = 0;
  //数组的大小可以通过计算得到
  //sizeof(arr)整个数组大小   sizeof(arr[0])一个元素大小
  int sz = sizeof(arr) / sizeof(arr[0]);//数组的元素个数
  for (i = 0; i < sz; i++)//循环 打印整个数组
  {
    printf("%d ", arr[i]);//arr[i] i是变量 数组只是不能在创建时使用变量,访问时可以使用变量
  }
  printf("\n");
  for (i = 0; i < sz; i += 2)//循环 隔一个打印一个  i+=2
  {
    printf("%d ", arr[i]);
  }
  printf("\n");
  for (i = sz - 1; i >= 0; i--)//循环 逆序打印
  {
    printf("%d ", arr[i]);
  }
  return 0;
}


循环给数组赋值

#include<stdio.h>
int main()
{
  int arr[10] = { 0 };
  int i = 0;
  int sz = sizeof(arr) / sizeof(arr[0]);//数组元素个数
  for (i = 0; i < sz; i++)
  {
    scanf("%d", &arr[i]);//通过循环 给数组每个元素赋值
  }
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);//通过循环 打印每个数组元素
  }
  return 0;
}


sizeof 在数组中的使用

#include<stdio.h>
int main()
{
  int arr[10] = { 0 };
  printf("%d\n", sizeof(arr));//40 计算的是数组的总大小 单位是字节
  printf("%d\n", sizeof(arr[0]));//4  计算的是数组元素的大小 int  4
  int sz = sizeof(arr) / sizeof(arr[0]);//计算数组元素的的个数
  printf("%d\n", sz);//10
  return 0;
}


总结:

1.数组是使用下标来访问的,下标是从0开始的

2.数组的大小是可以通过计算得到的

3.一位数组在内存中的存储

#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    //通过循环打印数组元素的地址
    //会发现每相邻元素之间相差4  也是4个字节
    //%p 用来打印16进制地址   &取地址
    printf("&arr[%d] = %p\n", i, &arr[i]);
  }
  //可以得出结论 一维数组在内存中是连续存放的
  return 0;
}


仔细发现观察的结果,我们知道,随着数组下标的增长,元素的地址,也在有规律的递增,由此可以得出结论:数组在内存中是连续存放的,由低地址到高地址。

4.二维数组的创建和初始化

#include<stdio.h>
int main()
{
    //二维数组的创建
  char arr[3][8];//3行8列
  //数组初始化
  int arr1[4][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{4,5,6,7,8} };//4行5列
  //每一行再用{},分开
  int arr2[4][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7,4,5,6,7,8 };//这种写法一行排满才放下一行。
  int arr3[4][5] = { {1,2,3},{2,3,4},3,4,5,6,7,4,5,6,7 };//第一行和第二行指定只初识化前三个,后面的行排满换行
  int arr4[4][5] = { {1,2,3},{2,3,4},{3,4,5,6,7},{4,5,6,7} };//没有赋值的默认为0
  //二维数组初始化之后
  //二维数组行可以省略,列不可以省略
  int arr5[][5] = { {1,2,3},{2,3,4},{3,4,5,6,7},{4,5,6,7} };
  return 0;
}


注:二位数组下标的行和列都是从0开始的

5.二维数组的使用

#include<stdio.h>
int main()
{
  //初始化
  int arr1[4][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{4,5,6,7,8} };
  //打印
  int i = 0;
  for (i = 0; i < 4; i++)//i是行号
  {
    int j = 0;
    for (j = 0; j < 5; j++)//j是列号
    {
      printf("%d ", arr1[i][j]);//利用循环 打印二维数组
    }
    printf("\n");
  }
    //二维数组在内存中的存储
  //打印每个元素地址
  for (i = 0; i < 4; i++)
  {
    int j = 0;
    for (j = 0; j < 5; j++)
    {
      printf("&arr1[%d][%d] = %p\n", i, j, &arr1[i][j]);
    }
  }
  //可以发现每个元素地址也是相隔4  即4个字节 int类型
  //所以二维数组在内存中也是连续存放的  列不可省略是因为它们是连续的
  return 0;
}
//自己理解
//二维数组是 一维数组 的数组
//数组名+行 是 列的数组名


内存图解

 

6.数组作为函数参数

首先我们先理解一下数组名的含义

#include<stdio.h>
int main()
{
  //数组名通常情况下就是数组首元素的地址
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("%d\n", arr);
  printf("%d\n", &arr[0]);
  //有两个例外
  //1.sizeof(数组名)  数组名单独放在sizeof()内部,这里的数组名表示整个数组,计算的是整个数组的大小
  printf("%d", sizeof(arr));//整个数组大小  10*4 = 40
  //2.&数组名  这里的数组名也表示真个数组,这里取得是整个数组的大小
  printf("%d\n", &arr);//数组首元素的地址也整个数组的地址数值上相同
  //地址+1  是跳过一个元素
  printf("%d\n", arr + 1);   //地址加4   跳过一个元素
  printf("%d\n", &arr[0] + 1);  //地址加4  跳过一个元素
  printf("%d\n", &arr + 1); //数组地址+1是跳过了这个数组  加了40
  return 0;
}


我们写一个函数来对一直数进行排序

#include<stdio.h>
int bubble_sort(int arr[10], int sz)//可以把int arr[10]写成int *arr ,因为传入的是指针
{
  //数组传参传的是首元素地址    sizeof(arr)=4,因为arr是一个指针,只是数组首元素地址 大小为4 所以传入数组的元素个数sz
  //int sz = sizeof(arr) / sizeof(arr[0]);//1  
  //冒泡排序
  //每趟确定一个最大数
  for (int i = 0; i < sz - 1; i++)
  {
    //每一趟开始前假设数组已经有序 flag=0;
    int flag = 0;
    //一趟内部比较的对数
    for (int j = 0; j < sz - 1 - i; j++)
    {
      if (arr[j] > arr[j + 1])
      {
        //交换
        int t = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = t;
        //交换说明没有顺序
        int flag = 1;//改变flag
      }
    }
    if (flag == 0)//有序不再继续循环
    {
      break;
    }
  }
}
int main()
{
  int arr[10] = { 0 };
  int i = 0;
  int sz = sizeof(arr) / sizeof(arr[0]);
  for (i = 0; i < sz; i++)
  {
    scanf("%d", &arr[i]);
  }
  //排序 - 升序
  bubble_sort(arr,sz);
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);
  }
  return 0;
}


谢谢观看,希望对大家学习有帮助

相关文章
|
2月前
|
传感器 算法 安全
【C语言】两个数组比较详解
比较两个数组在C语言中有多种实现方法,选择合适的方法取决于具体的应用场景和性能要求。从逐元素比较到使用`memcmp`函数,再到指针优化,每种方法都有其优点和适用范围。在嵌入式系统中,考虑性能和资源限制尤为重要。通过合理选择和优化,可以有效提高程序的运行效率和可靠性。
187 6
|
3月前
|
存储 程序员 编译器
C 语言数组与指针的深度剖析与应用
在C语言中,数组与指针是核心概念,二者既独立又紧密相连。数组是在连续内存中存储相同类型数据的结构,而指针则存储内存地址,二者结合可在数据处理、函数传参等方面发挥巨大作用。掌握它们的特性和关系,对于优化程序性能、灵活处理数据结构至关重要。
|
3月前
|
存储 缓存 算法
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式
在C语言中,数据结构是构建高效程序的基石。本文探讨了数组、链表、栈、队列、树和图等常见数据结构的特点、应用及实现方式,强调了合理选择数据结构的重要性,并通过案例分析展示了其在实际项目中的应用,旨在帮助读者提升编程能力。
99 5
|
3月前
|
存储 C语言 计算机视觉
在C语言中指针数组和数组指针在动态内存分配中的应用
在C语言中,指针数组和数组指针均可用于动态内存分配。指针数组是数组的每个元素都是指针,可用于指向多个动态分配的内存块;数组指针则指向一个数组,可动态分配和管理大型数据结构。两者结合使用,灵活高效地管理内存。
|
3月前
|
存储 NoSQL 编译器
C 语言中指针数组与数组指针的辨析与应用
在C语言中,指针数组和数组指针是两个容易混淆但用途不同的概念。指针数组是一个数组,其元素是指针类型;而数组指针是指向数组的指针。两者在声明、使用及内存布局上各有特点,正确理解它们有助于更高效地编程。
|
3月前
|
存储 人工智能 算法
数据结构实验之C 语言的函数数组指针结构体知识
本实验旨在复习C语言中的函数、数组、指针、结构体与共用体等核心概念,并通过具体编程任务加深理解。任务包括输出100以内所有素数、逆序排列一维数组、查找二维数组中的鞍点、利用指针输出二维数组元素,以及使用结构体和共用体处理教师与学生信息。每个任务不仅强化了基本语法的应用,还涉及到了算法逻辑的设计与优化。实验结果显示,学生能够有效掌握并运用这些知识完成指定任务。
81 4
|
4月前
|
存储 编译器 C语言
【c语言】数组
本文介绍了数组的基本概念及一维和二维数组的创建、初始化、使用方法及其在内存中的存储形式。一维数组通过下标访问元素,支持初始化和动态输入输出。二维数组则通过行和列的下标访问元素,同样支持初始化和动态输入输出。此外,还简要介绍了C99标准中的变长数组,允许在运行时根据变量创建数组,但不能初始化。
81 6
|
4月前
|
存储 算法 C语言
C语言:什么是指针数组,它有什么用
指针数组是C语言中一种特殊的数据结构,每个元素都是一个指针。它用于存储多个内存地址,方便对多个变量或数组进行操作,常用于字符串处理、动态内存分配等场景。
|
4月前
|
存储 C语言
C语言:一维数组的不初始化、部分初始化、完全初始化的不同点
C语言中一维数组的初始化有三种情况:不初始化时,数组元素的值是随机的;部分初始化时,未指定的元素会被自动赋值为0;完全初始化时,所有元素都被赋予了初始值。
|
4月前
|
C语言
C语言数组
C语言数组
39 0

热门文章

最新文章