嵌入式学习 C语言 数组

数组 ：是一种构造数据类型

    由数据类型相同的n个元素所组成的一个有限集合；
    数组大小是固定的，大小为n*每个元素的大小
    每个元素都是相同的

一维数组

1.数组的定义
    
数据类型 数组名[N]
N ：1元素的数量；

2.需要是一个整型常量 或者整型常量表达式（c89）/（c99）

3.sizeof : 在编译阶段计算；c99；柔性数组（变长数组）

2.数组的访问:

数组名[下标]

1.下标从0开始到N-1

2.变量 变量 表达式

3.数组的初始化

1.全部初始化(初始化列表)
    int arry[ 5 ] ={1，2，3，4，5}
    注意:数量一致，类型匹配

2.局部初始化
    int arry[ 5 ] ={1，2，3}
    没有初始化的元素 初始化为0；

3.默认初始化
    int arry[ ]={1,2}
    数组元素个数由参数的数量确定

4.数组的存储特性
    1.单一性 数组所有元素类型相同
    2.有序性 元素在内存中是有序存放的
    3.连续性 元素存储是连续存储的
    
5.数组的常见操作.   数组不允许整体操作；
    1.遍历打印    
    2.便利比较+3
 

3.数组排序

1.冒泡排序   

 相邻两个元素间进行比较，大的数据向后放，小的往前放（升序）

#include <stdio.h>

int main(int argc, const char *argv[])
{
	int arry[10] = {0, 2, 4, 8, 1, -2, 18, 34, -12, 0};	
	int len = sizeof(arry) / sizeof(arry[0]);
	int j = 0;
	int i = 0;
	for (i = 0; i < len; i++)
	{
		scanf("%d", &arry[i]);
	}

	for (j = len - 1; j > 0; j--)
	{
		for (i = 0; i < j; i++)
		{
			if (arry[i] < arry[i + 1])
			{
				int swap = arry[i];
				arry[i] = arry[i + 1];
				arry[i + 1] = swap;
			}
		}
	}

	for (i = 0; i < len; i++)
	{
		printf("%d ", arry[i]);
	}
	putchar('\n');
	return 0;
}

2.选择排序

#include <stdio.h>
int main(int argc, const char *argv[])
{
	int arry[10] = {0, 2, 4, 8, 1, -2, 18, 34, -12, 0};	
	int len = sizeof(arry) / sizeof(arry[0]);
	int j = 0;
	int i = 0;
	for (i = 0; i < len; i++)
	{
		scanf("%d", &arry[i]);
	}

	for (i = 0; i < len - 1; i++)
	{
		for (j = i + 1; j < len; j++)
		{
			if (arry[i] > arry[j])
			{
				int swap = arry[i];
				arry[i] = arry[j];
				arry[j] = swap;
			}
		}
	}

	for (i = 0; i < len; i++)
	{
		printf("%d ", arry[i]);
	}
	putchar('\n');
	return 0;
}

二维数组

1. 二维数组：

由n个数据类型相同的一维数组所组成的数组；
如何去判断一个变量的类型名： 去掉变量名，即为类型名

2.二维数组的定义
类型名 数组名[M][N];

类型名：二维数组的元素一维数组的元素类型
M：二维数组的元素数量；
N: 二维数组的元素一维数组的元素数量

3. 二维数组的访问

数组名[m] ：
数组名[m][n]:
数组名：访问的二维数组的名称；
m: 访问二维数组的第m+1(一维数组)元素;
n：访问二维数组的第m+1(一维数组)元素的第n+1个元素

4.二维数组的初始化

初始化不等于赋值；

1.全部初始化
//int a[3]  = {1,2,3};

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

注意：数量一致，类型匹配； =
2.局部初始化

int arry[2][3] = {{1, 2, 3}};
int arry[2][3] = {{1, 2,}};
int arry[2][3] = {1, 2, 3, 4};
int arry[2][3] = {{0}};
int arry[2][3] = {0};

注意：没有初始化的元素，初始化为0；

3.默认初始化

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

5.二维数组的存储特性：
 

字符型数组

1.含义：由n个字符型数据元素所组成的数组；

2.字符型数组定义
char str[1024] = {0};
3.字符型数组访问
数组名[下标]；


4.字符型数组初始化

1.全部初始化

char str[5] = {'h', 'e', 'l', 'l', 'o'};               
char str[6] = {'h', 'e', 'l', 'l', 'o', '\0'};         
char str[6] = {"hello"};
char str[6] = "hello";

2.局部初始化

char str[5] = {'h', 'e', 'l'};
char str[10] = "hello";

char str[10] = {0};
char str[10] = "\0"    

3.默认初始化
 

char str[] = {'h', 'e', 'l', 'l', 'o'};     不是字符串
char str[] = "hello"; 是字符串
char str[] = "\0";

5.字符型数组的操作

耦合性：高耦合  不好
好的程序：低耦合，高内聚

1.输入：
scanf("%s %s", str);
gets(str);
不使用这两个函数如何从终端接收字符串，

2.输出
printf("%s %s", str);
puts(str);

字符型数组中字符串的遍历一般条件
while (str[i] != '\0')
{
}
3.字符串有效字符数量统计

strlen
#include <string.h>
size_t strlen(const char *s);

4.字符串拷贝

定义两个字符型数组
char str1[32] = {"hello world"};
char str2[32] = {0};
将字符串从str1拷贝到str2；

#include <string.h>

char *strcpy(char *dest, const char *src);

dest：拷贝到的目标空间；
src： 拷贝的源字符串空间；

函数返回值：
    拷贝到的目标空间的地址标号；

5.字符串拼接

定义两个字符型数组
将字符串从str1拷贝到str2；
输出：

char str1[32] = {"helloworld"};
char str2[32] = {"world"};

    #include <string.h>
char *strcat(char *dest, const char *src);

函数功能：字符串拷贝；

dest：拷贝到的目标空间；
src： 拷贝的源字符串空间；

函数返回值：
    拷贝到的目标空间的地址标号；