学习C语言第十九天

第一项

C 内存管理

内存是通过指针变量来管理的。通过一些函数和运算符，可以对内存进行操作，包括分配、释放、移动和复制等。

序号	函数和描述
1	*void calloc(int num, int size);** 在内存中动态地分配 num 个长度为 size 的连续空间，并将每一个字节都初始化为 0。它的结果是分配了 num*size 个字节长度的内存空间，并且每个字节的值都是 0。
2	*void free(void address);** 该函数释放 address 所指向的内存块,释放的是动态分配的内存空间。
3	*void malloc(int num);** 在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。
4	*void realloc(void address, int newsize);* 该函数重新分配内存，把内存扩展到 newsize。

注意：void * 类型表示未确定类型的指针。void * 类型可以通过类型转换强制转换为任何其它类型的指针。

动态分配内存

预先知道数组的大小，定义数组时较容易。

一个存储人名的数组，它最多容纳 100 个字符：

char name[100];

预先不知道需要存储的文本长度。

存储有关一个主题的详细描述，需要定义一个指针，该指针指向未定义所需内存大小的字符，后续再根据需求来分配内存

eg：

Name = Zara Ali
Description: Zara ali a DPS student in class 10th

可以使用 calloc() 来编写，只需把 malloc 替换为 calloc 即可

calloc(200, sizeof(char));

当动态分配内存时，有完全控制权，可以传递任何大小的值。

预先定义了大小的数组，定义后无法改变大小。

重新调整内存的大小和释放内存

当程序退出时，操作系统会自动释放所有分配给程序的内存，调用函数 free() 可释放内存。

可以通过调用函数 realloc() 来增加或减少已分配的内存块的大小。

eg：

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

int main()
{
char name[100];
char *description;

strcpy(name, "Zara Ali");

/* 动态分配内存 */
description = (char *)malloc( 30 * sizeof(char) );
if( description == NULL )
{
fprintf(stderr, "Error - unable to allocate required memory\n");
}
else
{
strcpy( description, "Zara ali a DPS student.");
}
/* 假设您想要存储更大的描述信息 */
description = (char *) realloc( description, 100 * sizeof(char) );
if( description == NULL )
{
fprintf(stderr, "Error - unable to allocate required memory\n");
}
else
{
strcat( description, "She is in class 10th");
}

printf("Name = %s\n", name );
printf("Description: %s\n", description );

/* 使用 free() 函数释放内存 */
free(description);
}

Name = Zara Ali
Description: Zara ali a DPS student.She is in class 10th

可以尝试一下不重新分配额外的内存，strcat() 函数会生成一个错误，存储 description 时可用的内存不足。

C 语言中常用的内存管理函数和运算符

malloc() 函数：用于动态分配内存。它接受一个参数（即需要分配的内存大小（以字节为单位）），并返回一个指向分配内存的指针。
free() 函数：用于释放先前分配的内存。它接受一个指向要释放内存的指针作为参数，并将该内存标记为未使用状态。
calloc() 函数：用于动态分配内存，并将其初始化为零。它接受两个参数，即需要分配的内存块数和每个内存块的大小（以字节为单位），并返回一个指向分配内存的指针。
realloc() 函数：用于重新分配内存。它接受两个参数，即一个先前分配的指针和一个新的内存大小，然后尝试重新调整先前分配的内存块的大小。如果调整成功，它将返回一个指向重新分配内存的指针，否则返回一个空指针。
sizeof 运算符：用于获取数据类型或变量的大小（以字节为单位）。
指针运算符：用于获取指针所指向的内存地址或变量的值。
& 运算符：用于获取变量的内存地址。
* 运算符：用于获取指针所指向的变量的值。
-> 运算符：用于指针访问结构体成员，语法为 pointer->member，等价于 (*pointer).member。
memcpy() 函数：用于从源内存区域复制数据到目标内存区域。它接受三个参数，即目标内存区域的指针、源内存区域的指针和要复制的数据大小（以字节为单位）。
memmove() 函数：类似于 memcpy() 函数，但它可以处理重叠的内存区域。它接受三个参数，即目标内存区域的指针、源内存区域的指针和要复制的数据大小（以字节为单位）。

第二项

C 未定义行为（Undefined behavior）

指程序的行为在 C 语言标准中没有明确定义，因此可以表现为任何结果。

当程序出现未定义行为时，可能会产生不可预测的结果，包括程序崩溃、数据损坏、安全漏洞，甚至可能看起来正常运行。

数组越界

当尝试访问数组的越界元素时，即访问数组的第0个元素之前或数组长度之后的元素时，编译器无法确定访问到的内存空间中存储的是什么内容。

int arr[3] = {1, 2, 3};
printf("%d\n", arr[5]); // 越界访问，结果未定义

解引用空指针

当尝试对空指针进行解引用操作时，编译器无法确定要访问的内存空间中存储的内容。

int *ptr = NULL;
printf("%d\n", *ptr); // 解引用空指针，结果未定义

未初始化的局部变量

当使用未初始化的局部变量时，其值是未定义的。

int x;
printf("%d\n", x); // x 未初始化，结果未定义

浮点数除以零

当尝试对浮点数进行除以零的操作时，结果是未定义的。

float x = 1.0;
float y = x / 0.0; // 浮点数除以零，结果未定义

整数除以零

当尝试对整数进行除以零的操作时，结果是未定义的。

int x = 10;
int y = x / 0; // 整数除以零，结果未定义

符号溢出

当整数运算导致结果超出了整数类型能表示的范围时，结果是未定义的。

signed char x = 127;
x = x + 1; // signed char 溢出，结果未定义

位移操作数太大

当执行位移操作时，位移的位数大于或等于操作数的位数时，结果是未定义的。

int x = 1;
int y = x << 32; // 位移操作数太大，结果未定义

错误的类型转换

当进行不安全的类型转换时，结果是未定义的。

int *ptr = (int *)malloc(sizeof(int));
float *fptr = (float *)ptr; // 错误的类型转换，结果未定义

内存越界

当向已经释放或未分配的内存写入数据时，结果是未定义的。

int *ptr = (int *)malloc(sizeof(int));
free(ptr);
*ptr = 10; // 内存越界，结果未定义

未定义的浮点数行为

比如比较两个 NaN（非数字）值是否相等，这是未定义的行为。

float x = sqrt(-1);
float y = sqrt(-1);
if (x == y) {
    printf("NaN values are equal\n");
}

其他

使用未定义的浮点数特性：依赖于特定硬件或实现的浮点数行为，如浮点数的精度或舍入行为。
函数参数数量不匹配：调用函数时提供的参数数量与函数定义不匹配，如 printf("%s %d", "Name")。
修改字符串字面量：尝试修改字符串字面量的内容，如 char *str = "Hello"; str[0] = 'h';。
使用未定义的程序状态：依赖于未定义的程序状态，如全局变量的初始值。
违反严格的语法规则：违反 C 语言的严格语法规则，如使用未声明的标识符。
多线程中的竞态条件：在多线程环境中，未同步的共享资源访问可能导致未定义行为。
使用未定义的标准库函数行为：某些标准库函数在特定条件下的行为可能是未定义的，如 fscanf() 在未匹配到任何输入时的行为。

如何规避

仔细阅读和遵守 C 语言标准：了解哪些操作可能导致未定义行为，并避免这些操作。
使用静态分析工具：这些工具可以帮助检测潜在的未定义行为。
进行彻底的测试：测试程序的不同执行路径，以确保程序在各种情况下都能正确运行。
避免依赖未定义行为：不要假设未定义行为会产生特定的结果。
使用安全的函数和库：使用标准库提供的、定义良好的函数，避免使用可能导致未定义行为的非标准或不安全的函数。

第三项

C 命令行参数

执行程序时，可以从命令行传值给 C 程序。这些值被称为命令行参数

命令行参数是一种从命令行获取输入的方法，可以用于运行程序时传递信息给程序。

命令行参数通过 main 函数的参数传递给程序。

int main(int argc, char *argv[]);

或者:

int main(int argc, char **argv);

argc (argument count): 表示命令行参数的数量，包括程序名本身。argc 至少为 1。
argv (argument vector): 是一个指向字符串数组的指针，其中每个字符串是一个命令行参数。数组的第一个元素（即 argv[0]）通常是程序的名称。接下来的元素是传递给程序的命令行参数。

下检查命令行是否有提供参数，并根据参数执行相应的动作：

eg：

#include <stdio.h>

int main( int argc, char *argv[] )
{
if( argc == 2 )
{
  printf("The argument supplied is %s\n", argv[1]);
}
else if( argc > 2 )
{
  printf("Too many arguments supplied.\n");
}
else
{
  printf("One argument expected.\n");
}
}

使用一个参数

$./a.out testing
The argument supplied is testing

使用两个参数

$./a.out testing1 testing2
Too many arguments supplied.

不传任何参数

$./a.out
One argument expected

argv[0] 存储程序的名称，argv[1] 是一个指向第一个命令行参数的指针，*argv[n] 是最后一个参数。

没有提供任何参数，argc 将为 1，传递了一个参数，argc 将被设置为 2。

多个命令行参数之间用空格（space）分隔，参数本身带有空格，那么传递参数的时候应把参数放置在双引号 "" 或单引号 '' 内部。

eg：

#include <stdio.h>

int main( int argc, char *argv[] )
{
printf("Program name %s\n", argv[0]);

if( argc == 2 )
{
  printf("The argument supplied is %s\n", argv[1]);
}
else if( argc > 2 )
{
  printf("Too many arguments supplied.\n");
}
else
{
  printf("One argument expected.\n");
}
}

使用一个用空格分隔的简单参数，参数括在双引号中

$./a.out "testing1 testing2"

Progranm name ./a.out
The argument supplied is testing1 testing2

使用场景

配置文件路径
模式选择（例如调试模式）
输入文件和输出文件名
运行时选项和标志（如 -v 表示详细模式）

注意事项

命令行参数通常是字符串，如果需要将其转换为数值类型，可以使用标准库函数如 atoi 或 strtol。
应该始终验证和处理命令行参数，以防止输入错误或恶意输入。

第四项

C 排序算法

冒泡排序（Bubble Sort）

一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。

eg：

#include <stdio.h>

// 函数声明
void bubble_sort(int arr[], int len);

int main() {
int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

bubble_sort(arr, len); // 调用冒泡排序函数

// 打印排序后的数组
for (int i = 0; i < len; i++) {
printf("%d ", arr[i]);
}

return 0;
}

// 冒泡排序函数
void bubble_sort(int arr[], int len) {
for (int i = 0; i < len - 1; i++) {
for (int j = 0; j < len - 1 - i; j++) {
// 交换元素位置
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}

选择排序（Selection sort）

一种简单直观的排序算法。先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

eg：

#include <stdio.h>

// 函数声明
void selection_sort(int a[], int len);

int main() {
int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

selection_sort(arr, len); // 调用选择排序函数

// 打印排序后的数组
for (int i = 0; i < len; i++) {
printf("%d ", arr[i]);
}

return 0;
}

// 选择排序函数
void selection_sort(int a[], int len) {
for (int i = 0; i < len - 1; i++) {
int min = i; // 记录最小值的位置，第一个元素默认最小
for (int j = i + 1; j < len; j++) {
if (a[j] < a[min]) { // 找到目前最小值
min = j; // 记录最小值的位置
}
}
// 交换两个变量
if (min != i) {
int temp = a[min];
a[min] = a[i];
a[i] = temp;
}
}
}

/*
// 自定义交换函数
void swap(int *a, int *b) {
int temp = *a;
*a = *b;
*b = temp;
}
*/

插入排序（Insertion Sort）

一种简单直观的排序算法。通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（用 {\displaystyle O(1)} {\displaystyle O(1)}的额外空间的排序），在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

eg：

#include <stdio.h>

// 函数声明
void insertion_sort(int arr[], int len);

int main() {
int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

insertion_sort(arr, len); // 调用插入排序函数

// 打印排序后的数组
for (int i = 0; i < len; i++) {
printf("%d ", arr[i]);
}

return 0;
}

// 插入排序函数
void insertion_sort(int arr[], int len) {
for (int i = 1; i < len; i++) {
int temp = arr[i]; // 当前待插入的元素
int j = i;
// 向右移动大于temp的元素
while (j > 0 && arr[j - 1] > temp) {
arr[j] = arr[j - 1];
j--;
}
arr[j] = temp; // 插入元素到正确位置
}
}

希尔排序（递减增量排序算法）

插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

eg：

#include <stdio.h>

// 函数声明
void shell_sort(int arr[], int len);

int main() {
int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

shell_sort(arr, len); // 调用希尔排序函数

// 打印排序后的数组
for (int i = 0; i < len; i++) {
printf("%d ", arr[i]);
}

return 0;
}

// 希尔排序函数
void shell_sort(int arr[], int len) {
// 计算初始间隔
for (int gap = len / 2; gap > 0; gap /= 2) {
// 对每个间隔进行插入排序
for (int i = gap; i < len; i++) {
int temp = arr[i]; // 当前待插入的元素
int j = i;
// 移动大于temp的元素
while (j >= gap && arr[j - gap] > temp) {
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp; // 插入元素到正确位置
}
}
}

归并排序

把数据分为两段，从两段中逐个选最小的元素移入新数据段的末尾。

可从上到下或从下到上进行。

迭代法

#include <stdio.h>
#include <stdlib.h>

// 函数声明
int min(int x, int y);
void merge_sort(int arr[], int len);

int main() {
int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

merge_sort(arr, len); // 调用归并排序函数

// 打印排序后的数组
for (int i = 0; i < len; i++) {
printf("%d ", arr[i]);
}

return 0;
}

// 返回两个数中的最小值
int min(int x, int y) {
return x < y ? x : y;
}

// 归并排序函数
void merge_sort(int arr[], int len) {
int* a = arr;
int* b = (int*) malloc(len * sizeof(int));

if (b == NULL) { // 检查内存分配是否成功
fprintf(stderr, "Memory allocation failed\n");
exit(EXIT_FAILURE);
}

for (int seg = 1; seg < len; seg += seg) {
for (int start = 0; start < len; start += seg + seg) {
int low = start;
int mid = min(start + seg, len);
int high = min(start + seg + seg, len);
int k = low;
int start1 = low, end1 = mid;
int start2 = mid, end2 = high;

// 合并两个子数组
while (start1 < end1 && start2 < end2) {
b[k++] = a[start1] < a[start2] ? a[start1++] : a[start2++];
}
while (start1 < end1) {
b[k++] = a[start1++];
}
while (start2 < end2) {
b[k++] = a[start2++];
}
}

// 交换数组指针
int* temp = a;
a = b;
b = temp;
}

// 如果a和arr不相同，则将a的内容复制回arr
if (a != arr) {
for (int i = 0; i < len; i++) {
b[i] = a[i];
}
b = a;
}

free(b); // 释放内存
}

递归法

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

// 函数声明
void merge_sort_recursive(int arr[], int reg[], int start, int end);
void merge_sort(int arr[], const int len);

int main() {
int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

merge_sort(arr, len); // 调用归并排序函数

// 打印排序后的数组
for (int i = 0; i < len; i++) {
printf("%d ", arr[i]);
}

return 0;
}

// 递归实现归并排序
void merge_sort_recursive(int arr[], int reg[], int start, int end) {
if (start >= end)
return;

int mid = start + (end - start) / 2;
int start1 = start, end1 = mid;
int start2 = mid + 1, end2 = end;

merge_sort_recursive(arr, reg, start1, end1);
merge_sort_recursive(arr, reg, start2, end2);

int k = start;
while (start1 <= end1 && start2 <= end2) {
reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
}
while (start1 <= end1) {
reg[k++] = arr[start1++];
}
while (start2 <= end2) {
reg[k++] = arr[start2++];
}

// 使用memcpy进行数组复制，提高效率
memcpy(arr + start, reg + start, (end - start + 1) * sizeof(int));
}

// 归并排序入口函数
void merge_sort(int arr[], const int len) {
int* reg = (int*)malloc(len * sizeof(int));
if (reg == NULL) { // 检查内存分配是否成功
fprintf(stderr, "Memory allocation failed\n");
exit(EXIT_FAILURE);
}
merge_sort_recursive(arr, reg, 0, len - 1);
free(reg); // 释放内存
}

快速排序

在区间中随机挑选一个元素作基准，将小于基准的元素放在基准之前，大于基准的元素放在基准之后，再分别对小数区与大数区进行排序。

迭代法

#include <stdio.h>

// 范围结构体
typedef struct _Range {
int start, end;
} Range;

// 创建新的范围
Range new_Range(int s, int e) {
Range r;
r.start = s;
r.end = e;
return r;
}

// 交换两个整数
void swap(int *x, int *y) {
int t = *x;
*x = *y;
*y = t;
}

// 快速排序函数
void quick_sort(int arr[], const int len) {
if (len <= 0)
return; // 避免 len 等于负值时引发段错误（Segment Fault）

Range r[len];
int p = 0;
r[p++] = new_Range(0, len - 1);

while (p > 0) {
Range range = r[--p];
if (range.start >= range.end)
continue;

int mid = arr[(range.start + range.end) / 2]; // 选取中间点为基准点
int left = range.start, right = range.end;

do {
while (arr[left] < mid) ++left; // 检测基准点左侧是否符合要求
while (arr[right] > mid) --right; // 检测基准点右侧是否符合要求

if (left <= right) {
swap(&arr[left], &arr[right]);
left++;
right--; // 移动指针以继续
}
} while (left <= right);

if (range.start < right) r[p++] = new_Range(range.start, right);
if (range.end > left) r[p++] = new_Range(left, range.end);
}
}

int main() {
int arr[] = {22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70};
int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

quick_sort(arr, len); // 调用快速排序函数

// 打印排序后的数组
for (int i = 0; i < len; i++) {
printf("%d ", arr[i]);
}

return 0;
}

递归法

#include <stdio.h>

// 交换两个整数
void swap(int *x, int *y) {
int t = *x;
*x = *y;
*y = t;
}

// 递归实现快速排序
void quick_sort_recursive(int arr[], int start, int end) {
if (start >= end)
return;

int mid = arr[end];
int left = start, right = end - 1;

while (left < right) {
while (left < right && arr[left] < mid)
left++;
while (left < right && arr[right] >= mid)
right--;
swap(&arr[left], &arr[right]);
}

if (arr[left] >= arr[end])
swap(&arr[left], &arr[end]);
else
left++;

quick_sort_recursive(arr, start, left - 1);
quick_sort_recursive(arr, left + 1, end);
}

// 快速排序入口函数
void quick_sort(int arr[], int len) {
quick_sort_recursive(arr, 0, len - 1);
}

int main() {
int arr[] = {22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70};
int len = sizeof(arr) / sizeof(arr[0]); // 计算数组长度

quick_sort(arr, len); // 调用快速排序函数

// 打印排序后的数组
for (int i = 0; i < len; i++) {
printf("%d ", arr[i]);
}

return 0;
}