C语言目录
 
C/C++学习资源（百度云盘链接）
 计算机二级资料（过级专用）
 C语言学习路线（从入门到实战）
 编写C语言程序的7个步骤和编程机制
 C语言基础-第一个C程序
 C语言基础-简单程序分析
 VS2019编写简单的C程序示例
 简单示例，VS2019调试C语言程序
 C语言基础-基本算法
 C语言基础-数据类型
 C语言中的输入输出函数
 C语言流程控制语句
 C语言数组——一维数组
 C语言数组——二维数组
 
前面两篇文章分别介绍了一维数组和二维数组，今天我们一起看看字符数组
 
字符数组
 
字符数组顾名思义就是数组的元素类型为字符型的数组。特殊之处在于它是数组元素为字符的数组。其定义的一般形式和注意事项与之前讲解的一般数组类似，只是其中的类型说明符是char。当然，并不是说类型说明符只能是char，也可以是long、int等，但是由于char型只占用一个字节的大小，使用long型和int型来定义字符数组会造成资源的浪费，因此一般选择使用char型来定义字符数组。
 一维字符数组
 首先通过下面一段代码来看看一维字符数组的定义。
 
#include<stdio.h>
#define SIZE 20
int main() {
    long arr1[SIZE] = {'h','e','l','l','o',' ','w','o','r','l','d','!'};
    char arr2[SIZE] = { 'h','e','l','l','o',' ','w','o','r','l','d','!' };
    printf("long型字符数组占用的内存大小为：%d\n", sizeof(arr1));
    printf("char型字符数组占用的内存大小为：%d\n", sizeof(arr2));
    return 0;
}
 
运行结果：
 
 在上面的代码中定义了不同类型的字符数组来存放相同的字符，可以看出，它们占用的内存大小相差很大，long型字符数组所占用内存大小是char型数组占用内存大小的4倍。从这点可以看出，选用char型作为数组类型避免了内存空间的浪费。下面通过一段代码来了解字符数组的初始化特点。
 
#include<stdio.h>
#define SIZE 20
int main() {
    int i;
    char arr[SIZE] = { 'h','e','l','l','o',' ','w','o','r','l','d','!' };
    for (i = 0; i < SIZE; i++)
    {
        printf("%c", arr[i]);
    }
    
    return 0;
}
 
运行结果：
 
 运行结果为“Hello World!”，其中有一些空字符。看看上面代码中定义的arr数组，其数组长度为20，而初始化的字符元素的个数为12，初始化的字符元素个数小于数组长度，编译器在编译过程中将后面没有初始化的数组元素赋值为‘\0’，这也正是打印输出中含有空字符的原因。在打印的时候也可以将数组中的元素‘\0’视为数组结束的标志，例如：
 
#include<stdio.h>
#define SIZE 20
int main() {
    int i;
    long arr[SIZE] = { 'h','e','l','l','o',' ','w','o','r','l','d','!' };
    for (i = 0; arr[i]!='\0'; i++)
    {
        printf("%c", arr[i]);
    }
    
    return 0;
}
 
运行结果：
 
 这时的输出结果中就不含有任何空字符了，因为巧妙地使用了字符数组中的‘\0’标志。当然，也可以采用字符串常量的方式来对一维字符数组进行初始化，例如：
 
#include<stdio.h>
#define SIZE 20
int main() {
    int i;
    char arr[SIZE] = { "hello world!" };
    for (i = 0; arr[i] != '\0'; i++)
    {
        printf("%c", arr[i]);
    }
    
    return 0;
}
 
运行结果：
 
 在对一维字符数组进行定义和初始化的过程中，可以不指定其长度。使用字符常量列表和字符串常量的方式进行初始化的结果是不同的，例如：
 
#include<stdio.h>
int main() {
    int i;
    char arr1[] = { "hello world!" };
    char arr2[] = {'h','e','l','l','o',' ','w','o','r','l','d','!'};
    
    printf("采用字符串常量进行初始化的arr1数组的长度为：%d\n", sizeof(arr1));
    printf("采用字符常量列表进行初始化的arr2数组的长度为：%d\n", sizeof(arr2));
    
    return 0;
}
 
运行结果：
 
 从运行结果发现，采用这两种方式得到的数组长度并不相同，在采用字符串常量对字符数组进行初始化的过程中，在内存中进行存储时会自动在字符串的后面添加一个结束符‘\0’，所以得到的字符数组长度是字符串常量的长度加1；而采用字符常量列表的方式对字符数组进行初始化就不会在最后添加一个结束符，所以利用这种方式定义的字符数组的长度就是字符常量列表中字符的个数。
 
如果您觉得本篇文章对您有帮助，请转发给更多的人
 【C语言中文社区】是一个C语言视频教程、学习笔记、电子书、计算机二级资料等专注于C语言编程学习者的干货知识分享平台，精选深度文章，分享优秀干货类、技能类的学习资源，帮助学习中的你。
 

C语言目录
 
C/C++学习资源（百度云盘链接）
 计算机二级资料（过级专用）
 C语言学习路线（从入门到实战）
 编写C语言程序的7个步骤和编程机制
 C语言基础-第一个C程序
 C语言基础-简单程序分析
 VS2019编写简单的C程序示例
 简单示例，VS2019调试C语言程序
 C语言基础-基本算法
 C语言基础-数据类型
 C语言中的输入输出函数
 C语言流程控制语句
 C语言数组——一维数组
 
二维数组
 
前面介绍了一维数组，接下来介绍如何定义和使用二维数组。
 
二维数组定义的一般形式如下：
 
类型说明符 数组名[常量表达式1][常量表达式2]
 
与一维数组的定义唯一的不同是多了一个常量表达式2，其中，常量表达式1为第一维的长度，常量表达式2为第二维的长度。通常在处理二维数组的时候，为了便于理解，都将数组视为一个矩阵，常量表达式1表示矩阵的行数，而常量表达式2表示矩阵的列数。与一维数组一样，在定义二维数组时，常量表达式同样不能为变量。下面先通过一段代码来看二维数组的定义。
 
#include<stdio.h>

#define M 4
#define N 3


int main() {
  int arr[M][N];
  for (int i = 0; i < M; i++)
  {
    for (int j = 0; j < N; j++)
    {
      printf("&arr[%d][%d]=%d\t", i, j, &arr[i][j]);
    }
    printf("\n");
  }
  return 0;
}
 
运行结果：
 
 将二维数组arr视为一个矩阵，下图显示了数组中每个元素在矩阵中的存放位置。
 
 数组中各个元素在矩阵中对应的位置由二维数组的两个下标决定。我们可以将定义的二维数组int arr[4][3]视为由arr[4]和int [3] 两部分构成，将arr[4]视为一个整型一维数组，其中含有4个元素arr[0]、arr[1]、arr[2]、arr[3]，每个元素都是int[3]类型的，也就是说，每个元素又是一个一维数组，每个一维数组含有3个元素，如arr[0]含有arr[0][1]、arr[0][1]、arr[0][2]三个元素。
 
知道了二维数组的这种特殊结构之后，接下来通过下图来了解二维数组在内存中的存储结构。
 
 通过上述二维数组在内存中的存储结构图可以发现，二维数组中的所有元素都存储在一片连续的内存单元中，所占用的内存大小为元素类型所占用的内存大小乘以第一维及第二维的长度。如果以矩阵的方式来分析二维数组的存储方式，那么先从矩阵第一行从左往右依次存储完所有元素，然后按照同样的方法存储第二行的所有元素，直到存储完所有数组元素为止。
 
接下来再看一个二维数组的示例：
 
任意输入一个3行3列的二维数组，求对角元素之和
 
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>

int main() {
  int arr[3][3];
  int i, j, sum = 0;
  printf("please input:\n");
  for (i = 0; i < 3; i++)
  {
    for (j = 0; j < 3; j++)
    {
      scanf("%d", &arr[i][j]);
    }
  }
  for (i = 0; i < 3; i++)
  {
    for ( j = 0; j < 3; j++)
    {
      if (i==j)
      {
        sum += arr[i][j];
      }
    }
  }
  printf("the result is: %d\n", sum);
  return 0;
}
 
运行结果如下：
 
 关于以为数组就介绍到这，后面继续更新。。。
 
如果您觉得本篇文章对您有帮助，请转发给更多的人
 【C语言中文社区】是一个C语言视频教程、学习笔记、电子书、计算机二级资料等专注于C语言编程学习者的干货知识分享平台，精选深度文章，分享优秀干货类、技能类的学习资源，帮助学习中的你。
 

 
 
 
  
●🧑个人主页:你帅你先说.
 
  
●📃如果文章有帮助,欢迎点赞👍关注💡收藏💖
 
  
●📖既选择了远方，便只顾风雨兼程。
 
  
●🤟欢迎大家有问题随时私信我！
 
  
●🧐版权：本文由[你帅你先说.]原创，CSDN首发，侵权必究。
 
 
 
 
目录
 
 
1.一维数组的创建和初始化 
 
 
1.1一维数组的创建
 
 
1.2一维数组的初始化
 
 
1.3一维数组的使用
 
 
1.4一维数组在内存中的存储
 
 
2.二维数组的创建和初始化
 
 
2.1 二维数组的创建
 
 
2.2 二维数组的初始化
 
 
2.3 二维数组的使用
 
 
2.4 二维数组在内存中的存储
 
 
3.数组越界
 
 
4.冒泡排序
 
 

 
1.一维数组的创建和初始化 
 
 
1.1一维数组的创建
 
 
type_t   arr_name   [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小
 
 
例如
 
 
int arr[10];
char arr[20];
 
 
特别注意:[ ]中必须是常量表达式！
 
 
1.2一维数组的初始化
 
 
int arr1[20] = {1,2,3};//不完全初始化，剩余的默认初始化为0
int arr2[] = { 1,2,3};//数组元素个数视大括号内而定
char arr3[] = "abc";//结尾默认补上\0，数组内容为abc\0
char arr4[] = { 'a', 'b', 'c' };//数组内容为abc
char arr5[] = { 'a', 98, 'c' };//数组内容为abc
//arr5[]中，因为b所对应的ASCII码值为98，所以98在数组中以字符b存在
 
 
1.3一维数组的使用
 
 
#include <stdio.h>
int main()
{
 int arr[10] = {0};//数组的不完全初始化
    //计算数组的元素个数
    int sz = sizeof(arr)/sizeof(arr[0]);
 //对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
 int i = 0;//做下标
 for(i=0; i<sz; i++)//
 {
 arr[i] = i;
 } 
 //输出数组的内容
 for(i=0; i<sz; ++i)
 {
 printf("%d ", arr[i]);
 }
 return 0; }
 
1.4一维数组在内存中的存储
 
 
 
#include <stdio.h>
int main()
{
 int arr[10] = {0};
 int i = 0;
 for(i=0; i<sizeof(arr)/sizeof(arr[0]); ++i)
 {
 printf("&arr[%d] = %p\n", i, &arr[i]);
 }
 return 0; }
 
 
输出结果
 
 
 
 

  通过观察我们可以知道,随着数组下标的增长，元素的地址也在有规律的递增。 
 
 
 

  由此可以得出结论：
  数组在内存中是连续存放的。
 
 
 
2.二维数组的创建和初始化 
 
 
2.1 二维数组的创建 
 
 
int arr[3][4];
char arr[3][5];
double arr[2][4];
 
 
 
  
2.2 二维数组的初始化 
 
  
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};
char arr[3][4] = {"abc","def","qwe"};
 
  
第二种初始化方式与第一种不同，第一种方式是每行存满后进入下一行，而第二种方式则是第一行存1、2，第二行存4、5，其余位置以0补齐。同理，第四种初始化原理和第二种相同，每个" "代表不同行，每行以'\0'为结尾。
 
  
注意:二维数组的初始化行可以省略，列不能省略！
 
  
 
   
2.3 二维数组的使用 
 
   
#include <stdio.h>
int main()
{
     int arr[3][4] = {{1,2,3},{4},{5,6}};
     int i = 0;
     for(i=0; i<3; i++)//行数
     {
         int j = 0;
         for(j=0; j<4; j++)//列数
         {
         printf("%d ", arr[i][j]);
         }
        printf("\n");
     }
     return 0;
 }
打印结果为   1 2 3 0 
            4 0 0 0    
            5 6 0 0
 
   
 
    
 2.4 二维数组在内存中的存储
 
   
 
  
 
 
 
 
#include <stdio.h>
int main()
{
     int arr[3][4];
     int i = 0;
     for(i=0; i<3; i++)
     {
         int j = 0;
         for(j=0; j<4; j++)
         {
         printf("&arr[%d][%d] = %p\n", i, j,&arr[i][j]);
         }
     }
     return 0;
}
 
 
输出结果
 
 
 
 
 通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。 
 
 
所以二维数组的存储不是这样
 
 
 
 
而是这样的
 
 
 
 
3.数组越界
 
 
 
  

   数组的下标是有范围限制的。 
  
 
  

   数组的下规定是从
   0
   开始的，如果输入有
   n
   个元素，最后一个元素的下标就是
   n-1
   。 
  
 
  

   所以数组的下标如果小于
   0
   ，或者大于
   n-1,
   就是数组越界访问了,超出了数组合法空间的访问。
  
 
  
 
 
 
 
 
  
#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,10};
    int i = 0;
    for(i=0; i<=10; i++)
    {
        printf("%d\n", arr[i]);//当i等于10的时候，越界访问了
    }

     return 0;
}
 
  
输出结果
 
  
 
  
 超出范围后就出现了随机值。
 
  
注意:C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最好自己做越界的检查。
 
  
4.冒泡排序
 
  
图解
 
  
 
  
void Sort(int* arr, int sz)
{
	int i = 0;
	//冒泡排序的趟数
	for (i = 0; i < sz - 1; i++)
	{
		//一趟冒泡排序的过程
		int j = 0;
		int flag = 1;//假设已经有序
		for (j = 0; j < sz-1-i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				//交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
				flag = 0;	
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}
#include<stdio.h>
int main()
{
	int i;
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	Sort(arr, sz); 
	for (i = 0; i < 10; i++)
	{
		printf("%d", arr[i]);
	}
	return 0;
}
 
  
有的人会疑惑，sz为什么也要作为参数传过去，在函数内部算不就行了。实际上arr在主函数里，sizeof（arr）中arr代表的是整个数组，当你把数组传参给函数时，函数是以指针的方式接收，相当于是传了个地址过去，这样就会导致在自定义函数内部计算sizeof（arr）是4个字节（以32bit为例），再除每个元素的大小，算出来是1个元素，这就与实际不符合了。
 
  
这里的flag是为了提升效率的，如果一组数本来就是有序的，你再进行排序就多此一举了，所以在这里增加个判断是否有序，如果有序直接跳出去，避免无用功，造成程序效率低下。
 
  
在这里总结一下：
 
  
数组名就是首元素的地址
 
  
有2个例外：
 
  
1. sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小。
 
  
2. &数组名，这里的数组名表示整个数组，取出的是数组的地址。
 
  
我们可以进行验证
 
  
 
  
虽然三个地址都是一样的，但意义不一样。第一个和第二个代表都是首元素的地址，而第三个表示的是整个数组的地址。
 
 
 
 
 
 
显然，前两个+1跳过的只是4个字节，而&arr+1跳过的是整个数组，40个字节。
 
 
5.数组与字符数组
 
 
 
 
这道题很多人可能会选择D，为什么会这样认为呢，因为他以为第一个是" "初始化方式，所以结尾会添\0,所以长度为7,第二个则是随机值但一定比7大。请大家仔细审题，这道题题目问的是数组的长度，而你刚刚所想的确实用strlen函数算出来的长度。数组X里的内容应该是abcdefg\0，长度应为8，而数组Y里的内容为abcdefg，长度为7，所以本题为C。 
 
 
看完这些，我相信你现在应该是这样的
 
 
 
 
但别气馁，学习的过程总是痛苦的。
 
 
 
 
 
 
本人水平有限，请大家批评指正！喜欢我就点个关注吧！

C语言数组练习题目
 
1、编写程序，输入10个整数存入一维数组，统计输出其中的正数、负数和零的个数。
 
#include<stdio.h>
main()
{
	int a[10],i,j=0,k=0,l=0;
	printf("请输入10个整数:");
	for(i=0;i<10;i++)
	{
		scanf("%d",&a[i]);
	}
	for(i=0;i<10;i++)
	{
		if(a[i]>0)
		++j;
		else if(a[i]==0)
		++k;
		else
		++l;
	}
	printf("正数:%d,零:%d,负数:%d",j,k,l);
}

 
2、编写程序，输入10个整数存入一维数组，再按逆序重新存放后再输出
 
#include<stdio.h>
main()
{
	int i,a[10];
	for(i=0;i<=9;i++)
	scanf("%d",&a[i]);
	for(i=9;i>=0;i--)
	printf("%d ",a[i]);
}
 
3、输入10个整数，求出它们的和以及平均值并输出。
 
#include<stdio.h>
main()
{
	int i;
	float a[10],sum=0;
	printf("请输入10个整数:");
	for(i=0;i<=10;i++)
	{
		scanf("%f",&a[i]);
		sum=sum+a[i];
	}
	printf("和:%.0f,平均值:%f",sum,sum/10);
}
 
4、输入10个数，求出最大的数及其下标，以及最小的数及其下标
 
#include<stdio.h>
main()
{
	int a[10],i,max,i_max,min,i_min;
	scanf("%d",&a[0]);
	max=a[0];
	i_max=0;
	min=a[0];
	i_min=0;
	for(i=1;i<10;i++)
	{
		scanf("%d",&a[i]);
		if(a[i]>max)
		{
			max=a[i];
			i_max=i;
		}
		else if(a[i]<min)
		{
			min=a[i];
			i_min=i;
		}
	}
	printf("最大值=%d,下标=%d\n",max,i_max);
	printf("最小值=%d,下标=%d\n",min,i_min);
}
 
#由于编者水平有限,编写时间短促,难免存在不妥之处,敬请大家评判指正