一、uint8_t与char的区别

1.类型定义：

uint8_t：这是一个无符号 8 位整数类型，定义在 <stdint.h> 或 <inttypes.h> 头文件中。它是标准的固定宽度整数类型之一，确保在所有平台上占用 8 位（1 字节）。
char：这是 C 语言的基本字符存储类型，用于存储单个字符。在不同的系统和编译器中，char 可以是有符号的或无符号的，默认情况下通常是有符号的。

2.符号性：

uint8_t：作为无符号类型，uint8_t 的范围是 0 到 255。它不表示任何负值。
char：char 可以是有符号的或无符号的，这取决于具体的实现（编译器和系统）。如果是有符号的，其范围通常是 -128 到 127；如果是无符号的，其范围是 0 到 255。

3.用途：

uint8_t：主要用于表示确切的 8 位无符号整数值。它常用于需要精确控制数据大小和范围的场合，如处理二进制数据、协议构建、硬件接口等。
char：主要用于表示字符。它是 C 语言中字符串的基本构建块。尽管 char 通常用于存储字符，但它实际上是一个小的整数类型，可以存储超出标准 ASCII 码范围的值。

4.兼容性：

在大多数情况下，char 和 uint8_t 可以互换使用，因为它们都占用 1 个字节的空间。但在一些严格要求数据类型精确性的编程环境中，选择正确的类型是非常重要的。
总的来说，虽然 uint8_t 和 char 在许多情况下可以互换使用，但在设计程序时，选择正确的类型可以提高代码的清晰度和可移植性。如果你的意图是处理字符和字符串，使用 char 是更自然的选择；如果你的目的是处理精确的 8 位无符号数据，那么 uint8_t 是更合适的选择。

5.举例：
在 C 语言中，当我们声明一个数组，比如 char string[50];，这个声明实际上定义了一个字符数组，其中包含 50 个 char 类型的元素。然而，在大多数情况下，数组名称（在这个例子中是 string）可以作为指向数组第一个元素的指针。

这是因为在 C 语言中，数组名在大多数表达式中被解释为指向其首元素的指针。所以，当你声明了一个数组如 char string[50];，string 在大多数情况下被视为一个指向 char 类型的指针（char*），这个指针指向数组的第一个元素。

更具体地说：

void LCD_DisplayStringLine(u8 Line, uint8_t *ptr)
{
    
    u32 i = 0;
    u16 refcolumn = 319;//319;

    while ((*ptr != 0) && (i < 20))	 //	20
    {
    
        LCD_DisplayChar(Line, refcolumn, *ptr);
        refcolumn -= 16;
        ptr++;
        i++;
    }
}

char string[50];
double value=getADC_R38();
//将 double 格式化为字符串
sprintf(string,"%.2f",value);
LCD_DisplayStringLine(Line0,(uint8_t*)string);

在这段代码中
当使用 string 时，它表示指向数组第一个元素的指针。
当使用 &string 时，它表示指向整个数组的指针（在这种情况下，是指向一个有 50 个字符的数组的指针）。
当使用 string[i] 时，它访问数组的第 i 个元素，这是通过指针算术（string 加上 i）来实现的。
因此，在函数调用中，如 LCD_DisplayStringLine(Line0, (uint8_t*)string);，string 被用作指向数组首元素的指针，即使它实际上是一个数组。在这种情况下，强制类型转换 (uint8_t*) 确保了函数接收正确的指针类型，即使这在许多情况下可能是多余的，因为 char* 和 uint8_t* 在大多数平台上是兼容的。

本质：

在 <stdint.h>头文件中
typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;
typedef unsigned int uint32_t;
typedef unsigned __INT64 uint64_t;
所以uint8_t实际上就是 unsigned char

二、数组的强制类型转换

在 C 语言中，强制类型转换（Type Casting）是将一个变量从一种类型转换为另一种类型的过程。对于数组，这个过程稍有不同，因为数组的类型不仅包括元素的类型，还包括数组的大小和结构。通常，对于数组，我们更关心的是转换数组中元素的类型，而不是整个数组的类型。

1.转换数组元素的类型： 如果你想要转换数组中每个元素的类型，你需要逐个元素进行转换。例如，假设你有一个整型数组 intArray 并且想要将其每个元素转换为浮点型，可以这样做：

int intArray[] = {
    1, 2, 3};
float floatArray[3];

for (int i = 0; i < 3; i++) {
    
    floatArray[i] = (float)intArray[i];}

在这个例子中，数组 intArray 的每个元素都被强制转换为 float 类型，并存储在 floatArray 中。

2.转换数组到不同类型的指针： 你可以将数组的指针转换为另一种类型的指针。例如，你可以将指向 int 的指针转换为指向 char 的指针。这种转换在处理字节级数据时非常有用。

	int intArray[] = {
     65, 66, 67 };
	char* charPtr = (char*)intArray;

	for (int i = 0;i<12; i++)
	{
    
		cout <<charPtr[i] << endl;
	}

在这里，charPtr 现在指向 intArray 的第一个元素的起始地址，但被视为指向 char 的指针。这意味着通过 charPtr 访问数据时，它会按 char 的大小（通常是 1 字节）来处理数据，而不是按 int 的大小。

需要注意的是，强制类型转换可以导致数据解释上的变化，特别是在涉及不同大小和表示方式的数据类型时。因此，在进行类型转换时应当谨慎，确保转换是安全和适当的。
上述代码输出的结果为

我们来分析一下为什么A、B与C之间会空3行？

由于 intArray 是由整数 65, 66, 67 组成，每个整数在大多数系统中占用 4 个字节（取决于系统架构），这些整数在内存中的表示（假设是小端序）将是

65 -> 41 00 00 00 （ASCII 中的 ‘A’ 是 0x41）
66 -> 42 00 00 00 （ASCII 中的 ‘B’ 是 0x42）
67 -> 43 00 00 00 （ASCII 中的 ‘C’ 是 0x43）

因为char类型是1个字节，所以将首先输出 ‘A’，接着是三个不可打印字符（ASCII 0是不可打印字符），然后是 ‘B’，接着是三个不可打印字符，然后是 ‘C’，最后是三个不可打印字符。所以输出将是 ‘A’、三个不可打印字符、‘B’、三个不可打印字符、‘C’、三个不可打印字符。这些不可打印字符可能在控制台上显示为空白、乱码或根本不显示。而在图示中不可打印字符是属于不显示的，for循环中定义了换行操作，所以才会打印上图所示。

第一个示例：

uint8_t intArray[] = {
    65, 66, 67 };
char *charPtr = (char *)intArray;
cout << *charPtr << endl;

在第一个示例中，因为uint8_t跟char类型都是只占一个字节，所以不需要考虑内存大小的问题，可以直接转换。输出到屏幕上的就是字符A。

第二个示例：

void LCD_DisplayStringLine(u8 Line, uint8_t *ptr)
{
    
    u32 i = 0;
    u16 refcolumn = 319;//319;

    while ((*ptr != 0) && (i < 20))	 //	20
    {
    
        LCD_DisplayChar(Line, refcolumn, *ptr);
        refcolumn -= 16;
        ptr++;
        i++;
    }
}

char string[50];
sprintf(string,"value");
LCD_DisplayStringLine(Line0,(uint8_t*)string);

第二个示例中输出到屏幕的结果是value

可能大家会疑惑的是在这段代码中，已经进行uint8_t*的强制类型转换了，为什么输出到屏幕还是value呢？

在 C 和 C++ 中，char 和 uint8_t 通常都是 8 位（1 字节）的数据类型。因此，在内存中它们的表示是相同的。当您将 char* 类型转换为 uint8_t* 类型时，您实际上是在告诉编译器：“请将这块内存视为 uint8_t 类型的数组，而不是 char 类型的数组。” 但由于 char 和 uint8_t 在内存中的表示是相同的，这种转换并不会改变底层数据本身。

在第二个示例中，即使发生了类型转换，LCD_DisplayStringLine 函数仍然是按照字符的方式处理每个字节。这意味着，尽管类型转换发生了，但由于底层数据没有改变，函数仍然会按照原始的字符数据来处理和显示信息。

这与第一个示例中的情况不同。在第一个示例中，数组中存储的是数值，而当您使用 cout 来打印时，cout 根据 char 类型的特性将数值解释为相应的 ASCII 字符。

总的来说，类型转换的影响取决于上下文以及之后如何使用这些转换后的数据。在第二个示例中，即使发生了类型转换，显示的结果仍然是字符串 “value”，因为转换后的数据以字符的形式被处理和显示。而在第一个示例中，由于 cout 的行为，数值被解释为相应的字符。

三、数组与指针的联系和区别

数组和指针在 C 语言中是紧密相关但又有区别的两种概念。下面我会通过例子来说明它们的联系和区别：

1.联系：

数组名作为指针：在大多数情况下，数组名被当作指向数组首元素的指针。例如，如果有一个数组 int arr[10];，那么表达式 arr 就可以被视为指向 arr[0] 的指针。所以arr表示的地址值与&arr[0]是一致的，也就是说数组名也代表该数组的首地址。

指针运算和数组索引：指针可以通过增加偏移量来访问数组中的元素，这类似于使用数组索引。例如* (&arr[3] )与*(arr + 3) 是等价的，*(arr + 3) 和arr[3] 是等价的，都访问数组的第四个元素。

2.区别：

类型严格性：尽管数组名可以被当作指针，但它们的类型更严格。一个指向整数的指针可以指向任何整数，但一个特定类型的数组只表示这种类型元素的集合。

内存分配：数组在定义时就分配了固定大小的内存空间，而指针变量本身只是存储地址的变量，它可以在运行时指向任意大小的内存块。

可变性：数组名是固定的，不能被赋值为其他地址，而指针变量可以在其生命周期内指向不同的内存地址。

3.举例：

#include <stdio.h>

int main() {
    
    int arr[3] = {
    10, 20, 30};
    int *ptr = arr; // ptr 指向 arr 的第一个元素

    // 使用数组索引
    printf("%d\n", arr[1]); // 输出 20

    // 使用指针运算
    printf("%d\n", *(ptr + 1)); // 同样输出 20

    // ptr 可以改变指向
    int anotherValue = 40;
    ptr = &anotherValue;
    printf("%d\n", *ptr); // 输出 40

    // arr 不可以改变指向
    // arr = &anotherValue; // 这行代码会引发编译错误
}

在这个例子中，可以看到数组和指针在访问元素时的相似性，同时也展示了它们的主要区别，如内存分配和可变性。

四、访问数组中值的方式

1.通过数组索引:

这是访问数组元素最直接的方式。使用方括号 [] 与索引来访问特定位置的元素。例如，arr[i] 访问数组 arr 中的第 i+1 个元素（索引从 0 开始）。

2.使用数组名作为指针:

由于数组名本质上是指向数组首个元素的指针，你可以直接使用数组名加偏移量来访问元素，如 *(arr + i)。

3.通过指针加算术运算:

你可以使用指针和算术运算来访问数组元素。例如，如果 p 是一个指向数组 arr 的指针，则 *(p + i) 访问的是 arr[i] 相同的元素。

4.循环遍历:

使用循环结构（如 for 或 while 循环）来遍历数组中的每个元素。在循环体内，可以通过索引或指针访问当前元素。

5.指针迭代:

在数组上使用指针进行迭代，通常与循环结构结合使用。例如，通过递增指针（p++）来遍历数组。

6.函数传递:

将数组作为参数传递给函数。在函数内部，可以使用索引或指针来访问数组元素。

这些方法在不同的情境下各有优势，例如，指针方法在处理动态内存分配或高级数据结构时特别有用，而索引访问在代码可读性方面更胜一筹。

五、STM32中将字符显示到LCD屏幕注意点

从第一个字符开显示到屏幕上

	 int i=0;
 	 sprintf(str,"abcd%d",i);
	 LCD_DisplayStringLine(Line0, (uint8_t*)str);

如何从第二个字符开始显示到LCD屏幕中？

	 int i=0;
 	 sprintf(str,"abcd%d",i);
//这样就可以从第二个字符开始显示了！
	 LCD_DisplayStringLine(Line0, (uint8_t*)str+1);
//这样也是可以的
//LCD_DisplayStringLine(Line0, (uint8_t*)&str[1])

数组名就代表中首地址，str等价于&str[0]！