嵌入式学习--C语言Day05-CSDN博客

本文链接：https://blog.csdn.net/Xiaomo1536/article/details/142108485

嵌入式学习--C语言Day05

计算字符串实际元素个数

char a[33]="hello";
int i = 0;
for (; a[i] != '\0'; i++);
printf("%d\n",i);//i=5

strlen

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

功能：计算字符串实际元素个数不包括'\0'

参数：字符数组首地址

返回值：字符串实际元素个数

char a[33]="hello";
printf("%d\n",strlen(a));//5

输入输出

gets

#include <stdio.h>
char *gets(char *s);

功能：终端输入字符串

参数：字符数组首地址

返回值：字符数组首地址

puts

int puts(const char *s);

功能：终端输出字符串

参数：字符数组首地址

返回值：字符数量（包含‘\0’）

sizeof和strlen

sizeof是关键字，strlen是函数
sizeof计算元素实际开辟的空间大小，strlen计算字符串实际元素个数

sizeof计算包括'\0',strlen不包括'\0'

char a[ ] = “hello”；sizeof(a)==6 strlen(a) == 5

排序

冒泡排序

5个数，比较4轮

int a[5]={6,5,4,3,2}; //从小到大

第一轮：

56432

54632

54362

54326

第二轮：

45326

43526

43256

第三轮：

34256

32456

第四轮：

23456

int a[5] = {3,5,76,9,2};
for (int i = 0; i < 5-1; i++)    //控制轮数
{
	for (int j = 0; j < 5-1-i; j++)//控制每轮的比较次数
	{
		if (a[j] > a[j+1])
		{
			a[j] = a[j]^a[j+1];	
			a[j+1] = a[j]^a[j+1];
			a[j] = a[j]^a[j+1];
		}
	}
}

选择排序

假设第一个元素最小，和后边每一个进行比较，比较过程中遇到了更小值，暂存下标位置，直到一轮比较结束，再把最小值和最左边位置交换；

每次循环找最小元素与本次循环的初始位进行交换

int a[6] = {21,8,5,36,83,11},tmp;
for (int i = 0; i < 6-1; i++)    //轮数
{
    tmp = i;                        //最小元素下标，默认是参与比较的元素中最左边的位置
    for (int j = i+1; j < 6; j++)
    {
        if (a[tmp] > a[j])
        {
            tmp = j;                //获取最小元素下标
        }
    }
    if (tmp == i)                  //一轮循环结束，判断下标，交换元素位置
        continue;
    a[i] =a[i]^a[tmp];
    a[tmp] =a[i]^a[tmp];
    a[i] =a[i]^a[tmp];
}

二维数组

格式：

数据类型数组名[行数][列数]

int a[2][3] = {2,3,4,5,6,7};

访问：数组名[行下标][列下标] 下标从0开始

a[0][0]	a[0][1]	a[0][2]
a[1][0]	a[1][1]	a[1][2]

int a[2][3] = {2,3,4,5,7,8};
printf("%d %d\n",a[1][2],a[0][1]);//8  3

定义二维数组时可以省略行数，但是不能省略列数

数组名是第一行的首地址，是个行地址

a:第一行首地址

a+1：第二行首地址

int a[2][3] = {2,3,4,5,7,8};
printf("%p %p %p\n",a,&a[0][0],&a[0][1]);
printf("%p %p %p\n",a+1,&a[1][0],&a[1][1]);


0x7fffe5922e80 0x7fffe5922e80 0x7fffe5922e84
0x7fffe5922e8c 0x7fffe5922e8c 0x7fffe5922e90

数组元素个数 = 行数*列数

数组大小 = 行数*列数*数据类型大小

sizeof(数组名)

初始化

完初始化

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

int a[2][3] = {{2,3,4},{6,7,8}}; //按行赋值

部分初始化

未初始化部分，值为0

int a[2][3] = {2,3}; //2 3 0 0 0 0

int arr[2][3] = {{2},{5,6,7}}; //2 0 0 5 6 7

未初始化

值为随机数需要单独赋值

int a[2][3];

内存分配

		地址		元素
a[0]	&a[0][0]	a	2	a[0][0]
a[0]+1	&a[0][1]		3	a[0][1]
a[0]+2	&a[0][2]		4	a[0][2]
a[1]	&a[1][0]	a+1	5	a[1][0]
a[1]+1	&a[1][1]		6	a[1][1]
a[1]+2	&a[1][2]		7	a[1][2]

遍历数组

int a[2][3]={};
for(int i=0;i<2;i++)
{
    for(int j=0;j<3;j++)
        scanf("%d",&a[i][j]);
}
for(int i=0;i<2;i++)
{
    for(int j=0;j<3;j++)
        printf("%d\n",a[i][j]);
}