嵌入式学习-C语言-数组

记录每次学习的过程，总结学习的内容，希望能给到自己和别人帮助。

嵌入式学习-C语言-指针

数组名

数组名是一个地址的常量，代表数组中首元素的地址

#include <stdio.h>

int main() {
    // 定义一个数组，同时初始化所有成员变量
    int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 

    // 数组名是一个地址的常量，代表数组中首元素的地址
    printf("a = %p\n", a);
    printf("&a[0] = %p\n", &a[0]);

    int n = sizeof(a);     // 数组占用内存的大小，10个int类型，10 * 4  = 40
    int n0 = sizeof(a[0]); // 数组第0个元素占用内存大小，第0个元素为int，4
    int num = n / n0;      // 元素个数
    printf("n = %d, n0 = %d, num = %d\n", n, n0, num);

    return 0;
}

数组的初始化
● 在定义数组的同时进行赋值，称为初始化
● 全局数组若不初始化，编译器将其初始化为零
● 局部数组若不初始化，内容为随机值

数组案例

一维数组的最大值

#include <stdio.h>

int main() {
    // 定义一个数组，同时初始化所有成员变量
    int a[] = {1, -2, 3, -4, 5, -6, 7, -8, -9, 10};

    // 假设第0个元素就是最大值
    int temp = a[0];
    for (int i = 0; i < sizeof(a) / sizeof(a[0]); i++) {
        // 如果有元素比临时的最大值大，就交换值
        if (a[i] > temp) {
            temp = a[i];
        }
    }
    printf("数组中最大值为：%d\n", temp);

    return 0;
}

逆置

#include <stdio.h>

int main() {
    // 定义一个数组，同时初始化所有成员变量
    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; 

    int i = 0;  // 首元素下标
    int j = sizeof(a) / sizeof(a[0]) - 1;   // 尾元素下标
    int temp;

    while (i < j) {
        // 元素交换值
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
        // 位置移动
        i++;
        j--;
    }

    for (i = 0; i < sizeof(a) / sizeof(a[0]); i++) {
        printf("%d, ", a[i]);
    }

    return 0;
}

数组与指针

指针操作数组

数组名字是数组的首元素地址，但它是一个常量

• 和 [] 效果一样，都是操作指针所指向的内存
  

指针变量指向数组首元素

指针数组

● 指针数组，它是数组，数组的每个元素都是指针类型
每一个元素 都是每个变量取址&a; &b;&c;

#include <stdio.h>

int main() {
    // 指针数组
    int *p[3];
    int a = 1;
    int b = 2;
    int c = 3;

    // 指针变量赋值
    p[0] = &a;
    p[1] = &b;
    p[2] = &c;

    for (int i = 0; i < sizeof(p) / sizeof(p[0]); i++) {
        printf("%d, ", *(*(p + i)));
        // printf("%d, ", *(p[i]));
    }
    printf("\n");

    return 0;
}

数组名做函数参数（重点）

● 数组名做函数参数，函数的形参本质上就是指针变量（不是数组常量）
函数的参数列表的格式是：int *p 函数里面取值是printf("%d, ", a[i]);

#include <stdio.h>

// 下面3种写法完全等价
// void print_arr(int a[10], int n)
// void print_arr(int a[], int n)
void print_arr(int *a, int n) {
    int i = 0;
    for (i = 0; i < n; i++) {
        printf("%d, ", a[i]);
    }
    printf("\n");
}

int main() {
    int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    int n = sizeof(a) / sizeof(a[0]);

    // 数组名做函数参数
    print_arr(a, n);

    return 0;
}

#include <stdio.h>

//数组名用作函数的参数，本质上是一个指针，接收的话也需要指针变量类型的接收

void print_arr(int *p, int n) {
	for (int i = 0; i <= n - 1; i++) {
		printf("%d,", p[i]);
	}
}


int main() {
	int a[] = {1, 2, 3, 5, 8, 7, 9, 6, 10};
//如果是需要通过函数操作数组， 需要传递首元素地址，以及元素个数，因为在函数中不能计算出个数
	print_arr(a, (sizeof(a) / sizeof(a[0])));

	return 0;
}

字符数组与字符串

字符数组与字符串的区别

C语言中没有字符串这种数据类型，可以通过char的数组来替代，可以说字符串是一种特殊的char的数组。
如果字符数组的结尾是 ‘\0’或者数字0 证明这是一个字符串.
如果char数组没有以数字0结尾，那么就不是一个字符串，只是普通字符数组
char a[]={‘a’,‘b’,‘c’,’\0’}; ======> char a=“abc”; sizeof(a) ==4 个字符
`#include <stdio.h>

int main() {
char c1[] = {‘c’, ’ ‘, ‘p’, ‘r’, ‘o’, ‘g’}; // 普通字符数组
printf(“c1 = %s\n”, c1); // 有可能乱码，因为没有’\0’结束符

// 以'\0'('\0'就是数字0)结尾的字符数组是字符串
char c2[] = {'c', ' ', 'p', 'r', 'o', 'g', '\0'};
printf("c2 = %s\n", c2);

// 字符串处理以'\0'(数字0)作为结束符，后面的'h', 'l', 'l', 'e', 'o'不会输出
char c3[] = {'c', ' ', 'p', 'r', 'o', 'g', '\0', 'h', 'l', 'l', 'e', 'o', '\0'};
printf("c3 = %s\n", c3);

// 使用字符串初始化，编译器自动在后面补0，常用
char c4[] = "c prog";
printf("c4 = %s\n", c4);

return 0;

}`

字符的输入输出

● 由于字符串采用了’\0’标志，字符串的输入输出将变得简单方便
可以使用scanf，但是如果出现空格的话，会被截断，默认以空格分隔，所以指挥展示前边的字符
可以使用gets()方法，允许输入空格，也可以输出空格

#include <stdio.h>

int main()
{
    char str[100];

    printf("input string1: ");
    // scanf("%s",str) 默认以空格分隔
    // 可以输入空格
    gets(str);
    printf("output: %s\n", str);

    return 0;
}

字符指针

● 字符指针可直接赋值为字符串，保存的实际上是字符串的首地址
○ 这时候，字符串指针所指向的内存不能修改，指针变量本身可以修改
例如：
char * str = “HELLO”; //不能修改内容，因为这种定义方法是 文字常量区内容，只能获取不能修改
printf(“单个字符：%c\n”, str[0]);
printf(“字符串内容：%s\n”, str);
不能出现str [0] = ‘t’;这种修改操作

#include <stdio.h>

int main() {
	char arr[] = "hello";
	char * p = arr;

	printf("p[0]=%c\n", p[0]);
	p[0] = 't';
	printf("p[0]=%c\n", p[0]);
	printf("字符串内容p为:%s\n", p);
	printf("字符串内容arr为:%s\n", arr);

	printf("=====================================a=\n");
	
	char * str = "HELLO";	//不能修改内容，因为这种定义方法是 文字常量区内容，不能修改
	printf("单个字符：%c\n", str[0]);
	printf("字符串内容：%s\n", str);

	return 0;
}

字符串常用库函数

需要加入头文件<string.h>
strlen字符长度 strlen(s1);
strcpy拷贝，是等于覆盖 strcpy(s1,s2);
strcat连接，等于追加 strcat(s1,s2);
strcmp两个字符串比较大小，是比较字符ASCII码的大小(参数是首字符地址)
int flag=strcmp(s1,s2)
功能：比较 s1 和 s2 的大小，比较的是字符ASCII码大小。
参数：
s1：字符串1首地址
s2：字符串2首地址
返回值：
相等：0
大于：>0
小于：<0

#include <stdio.h>
#include <string.h>

int my_strlen(char * p) {
	int i = 0;
	while (p[i] != '\0') {
		i++;
	}
	return i;
}


int main() {
	//strlen 字符串长度
	char buf[] = "hello";
	int len = strlen(buf);
	printf("字符串长度len=%d\n", len);

	//strcpy 字符串拷贝
	char str[50] = "mike";
	char str2[] = "are you ok?";
	strcpy(str, str2);
	printf("字符串str为:%s\n", str);

	//strcat 字符串连接
	char str3[50] = "mike ";
	char str4[] = "are you ok?";
	strcat(str3, str4);
	printf("字符串str3为:%s\n", str3);

	//strcmp字符串比较
	char one[] = "mike";
	char two[] = "mike";
	char three[] = "are you ok?";
	int flag1 = strcmp(one, two);
	int flag2 = strcmp(one, three);
	printf("两次比较结果：flag=%d，flag2=%d\n", flag1, flag2);


	//定义一个函数my_strlen()，实现的功能和strlen一样
	char buff[] = "abcd";
	//因为传递的是首元素地址，首元素是char，形参需要char * 类型
	int leng = my_strlen(buff);
	printf("自定义函数-字符串长度为：%d\n", leng);

	return 0;
}

凡心所向，素履以往，生如逆旅，一苇以航。