📝 更新C语言文档，优化数组章节内容

- 在数组章节中增加了对数组定义、初始化和访问的详细说明，提升了对数组使用的理解。
- 删除了冗余的内容，简化了文档结构，增强了可读性。
- 新增了数组的内存存储细节和注意事项，帮助读者更好地理解数组的特性。

Author: jiangyangcreate

docs/docs/选择编程语言/C/0基础语法.mdx

@@ -12,11 +12,11 @@ title: 基础语法
 ### 函数定义格式
 
 - 主函数定义的格式:
-  - int 代表函数执行之后会返回一个整数类型的值
-  - main 代表这个函数的名字叫做 main
-  - () 代表这是一个函数
-  - {} 代表这个程序段的范围
-  - return 0; 代表函数执行完之后返回整数 0
+  - `int` 代表函数执行之后会返回一个整数类型的值
+  - `main` 代表这个函数的名字叫做 main
+  - `()` 代表这是一个函数
+  - `{}` 代表这个程序段的范围
+  - `return 0;` 代表函数执行完之后返回整数 0
 
 ```c showLineNumbers
 int main() {
@@ -31,11 +31,11 @@ int main() {
 :::
 
 - 其它函数定义的格式
-  - int 代表函数执行之后会返回一个整数类型的值
-  - call 代表这个函数的名字叫做 call
-  - () 代表这是一个函数
-  - {} 代表这个程序段的范围
-  - return 0; 代表函数执行完之后返回整数 0
+  - `int` 代表函数执行之后会返回一个整数类型的值
+  - `call` 代表这个函数的名字叫做 call
+  - `()`代表这是一个函数
+  - `{}` 代表这个程序段的范围
+  - `return 0;` 代表函数执行完之后返回整数 0
 
 ```c showLineNumbers
 int call() {

docs/docs/选择编程语言/C/1变量.mdx

@@ -240,65 +240,91 @@ int main(){
 
 类型字符串用以表示输出数据的类型, 其格式符和意义如下所示
 
-| 类型  | 含义                                |
-| ----- | ----------------------------------- |
-| c     | 字符                                |
-| f     | 单、双精度浮点数(默认保留 6 位小数) |
-| d / i    | 有符号 10 进制整型                  |
-| u     | 无符号 10 进制整型                  |
-| o     | 无符号 8 进制整型                   |
-| x / X    | 无符号 16 进制整型                  |
-| e / E | 以指数形式输出单、双精度浮点数      |
-| g / G | 以最短输出宽度,输出单、双精度浮点数 |
-| s     | 字符串                              |
-| p     | 地址                                |
-| n     | 不输出字符，将已输出字符数存储到指针指向的变量中 |
-| %     | 输出一个百分号字符 %                |
+| 类型  | 含义                                | 示例 |
+| ----- | ----------------------------------- | ---- |
+| **字符类型** |
+| c     | 单个字符                            | `%c` |
+| s     | 字符串（char 数组）                 | `%s` |
+| **整数类型** |
+| d / i | 有符号 10 进制整数                  | `%d`, `%i` |
+| hd / hi | short int（短整型）               | `%hd`, `%hi` |
+| ld / li | long int（长整型）                | `%ld`, `%li` |
+| lld / lli | **long long int（长长整型）**   | `%lld`, `%lli` |
+| u     | 无符号 10 进制整数                  | `%u` |
+| hu    | unsigned short int                 | `%hu` |
+| lu    | unsigned long int                  | `%lu` |
+| llu   | **unsigned long long int**         | `%llu` |
+| **其他进制整数** |
+| o     | 无符号 8 进制整数                   | `%o` |
+| lo    | unsigned long int（8进制）         | `%lo` |
+| llo   | **unsigned long long int（8进制）** | `%llo` |
+| x / X | 无符号 16 进制整数                  | `%x`, `%X` |
+| lx / lX | unsigned long int（16进制）       | `%lx`, `%lX` |
+| llx / llX | **unsigned long long int（16进制）** | `%llx`, `%llX` |
+| **浮点数类型** |
+| f     | float/double（默认保留 6 位小数）   | `%f` |
+| lf    | double（推荐用法）                  | `%lf` |
+| e / E | 科学计数法输出浮点数                | `%e`, `%E` |
+| g / G | 自动选择最短格式输出浮点数          | `%g`, `%G` |
+| **特殊类型** |
+| p     | 指针地址                            | `%p` |
+| n     | 不输出字符，存储已输出字符数        | `%n` |
+| %     | 输出百分号字符 %                    | `%%` |
 
 
 ```c showLineNumbers
 #include <stdio.h>
 int main(){
-    int a = 10;
-    int b = -10;
-    float c = 6.6f;
-    double d = 3.1415926;
-    double e = 10.10;
-    char f = 'a';
-    // 有符号整数(可以输出负数)
-    printf("a = %d\n", a); // 10
-    printf("a = %i\n", a); // 10
-
-    // 无符号整数(不可以输出负数)
-    printf("a = %u\n", a); // 10
-    printf("b = %u\n", b); // 429496786
-
-    // 无符号八进制整数(不可以输出负数)
-    printf("a = %o\n", a); // 12
-    printf("b = %o\n", b); // 37777777766
-
-    // 无符号十六进制整数(不可以输出负数)
-    printf("a = %x\n", a); // a
-    printf("b = %x\n", b); // fffffff6
-
-    // 无符号十六进制整数(不可以输出负数)
-    printf("a = %X\n", a); // A
-    printf("b = %X\n", b); // FFFFFFF6
-
-    // 单、双精度浮点数(默认保留6位小数)
-    printf("c = %f\n", c); // 6.600000
-    printf("d = %lf\n", d); // 3.141593
-
-    // 以指数形式输出单、双精度浮点数
-    printf("e = %e\n", e); // 1.010000e+001
-    printf("e = %E\n", e); // 1.010000E+001
-
-    // 以最短输出宽度,输出单、双精度浮点数
-    printf("e = %g\n", e); // 10.1
-    printf("e = %G\n", e); // 10.1
-
-    // 输出字符
-    printf("f = %c\n", f); // a
+    // 字符和字符串
+    char ch = 'A';
+    char str[] = "Hello";
+    printf("字符: %c\n", ch);           // A
+    printf("字符串: %s\n", str);        // Hello
+    
+    // 各种整数类型
+    short short_num = 12345;
+    int int_num = 123456;
+    long long_num = 1234567890L;
+    long long longlong_num = 1234567890123456789LL;
+    
+    printf("short: %hd\n", short_num);           // 12345
+    printf("int: %d\n", int_num);               // 123456
+    printf("long: %ld\n", long_num);            // 1234567890
+    printf("long long: %lld\n", longlong_num);  // 1234567890123456789
+    
+    // 无符号整数
+    unsigned int uint_num = 4294967295U;
+    unsigned long long ulonglong_num = 18446744073709551615ULL;
+    
+    printf("unsigned int: %u\n", uint_num);           // 4294967295
+    printf("unsigned long long: %llu\n", ulonglong_num); // 18446744073709551615
+    
+    // 不同进制输出
+    int num = 255;
+    printf("十进制: %d\n", num);        // 255
+    printf("八进制: %o\n", num);        // 377
+    printf("十六进制: %x\n", num);      // ff
+    printf("十六进制(大写): %X\n", num); // FF
+    
+    // long long 的不同进制
+    long long big_num = 255LL;
+    printf("long long 八进制: %llo\n", big_num);    // 377
+    printf("long long 十六进制: %llx\n", big_num);   // ff
+    
+    // 浮点数
+    float f_num = 3.14159f;
+    double d_num = 3.141592653589793;
+    
+    printf("float: %f\n", f_num);       // 3.141590
+    printf("double: %lf\n", d_num);     // 3.141593
+    printf("科学计数法: %e\n", d_num);   // 3.141593e+00
+    printf("自动格式: %g\n", d_num);     // 3.14159
+    
+    // 指针地址
+    int *ptr = &int_num;
+    printf("指针地址: %p\n", ptr);       // 类似 0x7fff5fbff6ac
+    
+    return 0;
 }
 ```
 

docs/docs/选择编程语言/C/2数据.mdx

@@ -390,3 +390,177 @@ int main(){
     printf("d = %lf\n", d); // 3.140000
 }
 ```
+
+## 数组
+
+在 C 语言中,数组属于**构造数据类型**，是一组`相同类型`数据的`连续内存`集合。
+
+数组的特点包括：
+
+- 固定大小（编译时确定）
+- 元素类型相同
+- 内存连续分配
+- 通过下标访问（从0开始）
+
+
+定义数组:`数据类型 数组名[数组长度];`
+
+```c showLineNumbers
+// int 元素类型
+// ages 数组名称
+// [10] 数组长度 即 元素个数
+int ages[10];
+// 数组名为ages, 数组类型为int [10]
+
+int scores[5];     // 5个整数的数组
+double temps[30];    // 30个双精度浮点数
+char name[20];     // 20个字符的字符数组，也叫字符串
+```
+
+
+### 初始化数组
+
+```c showLineNumbers
+// 完全初始化, 其中在{ }中的各数据值即为各元素的初值,各值之间用逗号间隔
+// 定义的同时可以初始化多个值
+int ages[3] = {4, 6, 9};
+
+// 完全初始化,不指定元素个数,自动计算长度
+int days[] = {31,28,31,30,31};  // 自动确定为5个元素
+
+// 部分初始化（剩余自动补0）
+int arr[5] = {1, 2};     // [1, 2, 0, 0, 0]
+
+// 部分初始化,指定位置的元素初始化
+int nums[5] = {[0] = 1,[1] = 2}; // [1, 2, 0, 0, 0]
+
+
+// 先定义后初始化
+int nums[3];
+
+nums[0] = 1;
+nums[1] = 2;
+nums[2] = 3;
+
+int ages[3]; // 定义后只能逐个初始化值
+ages = {4, 6, 9}; // 报错
+```
+
+如果定义数组后,<Highlight>没有初始化,数组中是随机的垃圾数</Highlight>,所以如果想要正确使用数组应该要进行初始化。
+
+
+:::info
+
+在定义数组的时候[]里面能写整型常量或者是返回整型常量的表达式
+
+不能写变量。
+
+```c showLineNumbers
+#include <stdio.h>
+
+int main() {
+    int ages1['A'] = {19, 22, 33};// 'A' 会被转换为 65
+    printf("ages1[0] = %d\n", ages1[0]);
+
+    int ages2[5 + 5] = {19, 22, 33};
+    printf("ages2[0] = %d\n", ages2[0]);
+
+    int ages3['A' + 5] = {19, 22, 33};// 'A' + 5会被转换为 70
+    printf("ages3[0] = %d\n", ages3[0]);
+
+    printf("sizeof(ages3) = %lu\n", sizeof(ages3));// 大小为 70 * 4 = 280
+}
+
+```
+:::
+
+### 数组元素的访问
+
+使用数组时不能超出数组的索引范围使用, 索引从 0 开始, 到元素个数-1 结束
+
+通过下标（索引）访问：
+
+```c showLineNumbers
+int nums[3] = {10, 20, 30};
+nums[0] = 15;       // 修改第一个元素
+int x = nums[2];     // 读取第三个元素
+
+// 越界访问
+int arr[3];
+arr[5] = 10;  // 未定义行为！可能破坏其他内存，导致程序崩溃
+```
+
+### 数组的遍历
+
+遍历的意思就是有序地查看数组的每一个元素
+
+```c showLineNumbers
+#include <stdio.h>
+int main() {
+    
+    int ages[4] = {11, 22, 33, 44};
+
+    // 正序输出(遍历)数组
+    for (int i = 0; i < 4; i++) {
+        printf("ages[%d] = %d\n", i, ages[i]);
+    }
+
+    // 逆序输出(遍历)数组
+    for (int i = 3; i >=0; i--) {
+        printf("ages[%d] = %d\n", i, ages[i]);
+    }
+
+    return 0;
+    }
+```
+
+
+### 数组的内存
+
+因为数组在内存中占用的字节数取决于其存储的数据类型和数据的个数
+
+数组所占用存储空间 = 一个元素所占用存储空间 x 元素个数(数组长度)
+
+可以使用`sizeof`函数来计算数组所占用的存储总空间和元素所占用的空间，进一步可以计算出数组的长度
+
+```c showLineNumbers
+#include <stdio.h>
+int main() {
+    int ages[4] = {19, 22, 33};
+    int length = sizeof(ages) / sizeof(ages[0]);
+    printf("length = %d\n", length); 
+    return 0;
+}
+
+```
+
+- 内存寻址从大到小, 从高地址开辟一块连续没有被使用的内存给数组
+- 从分配的连续存储空间中, 地址小的位置开始给每个元素分配空间
+- 从每个元素分配的存储空间中, 地址最大的位置开始存储数据
+- 用数组名指向整个存储空间最小的地址
+
+
+```c showLineNumbers
+#include <stdio.h>
+int main()
+{
+    int num = 9;
+    char cs[] = {'l','n','j'};
+    printf("cs = %p\n", &cs);       // cs = 0060FEA9
+    printf("cs[0] = %p\n", &cs[0]); // cs[0] = 0060FEA9
+    printf("cs[1] = %p\n", &cs[1]); // cs[1] = 0060FEAA
+    printf("cs[2] = %p\n", &cs[2]); // cs[2] = 0060FEAB
+
+    int nums[] = {2, 6};
+    printf("nums = %p\n", &nums);      // nums = 0060FEA0
+    printf("nums[0] = %p\n", &nums[0]);// nums[0] = 0060FEA0
+    printf("nums[1] = %p\n", &nums[1]);// nums[1] = 0060FEA4
+
+    return 0;
+}
+```
+
+![](https://images.weserv.nl/?url=https://img-blog.csdnimg.cn/img_convert/e0aa63f597f92632c90cd1c5f6adc292.png)
+
+> - 注意:字符在内存中是以对应 ASCII 码值的二进制形式存储的,而非上述的形式。
+