学习C语言 第十九天

第一项

C 内存管理

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

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

动态分配内存

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

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

char name[100];

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

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

eg：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main()
{
   char name[100];
   char *description;
 
   strcpy(name, "Zara Ali");
 
   /* 动态分配内存 */
   description = (char *)malloc( 200 * sizeof(char) );
   if( description == NULL )
   {
      fprintf(stderr, "Error - unable to allocate required memory\n");
   }
   else
   {
      strcpy( description, "Zara ali a DPS student in class 10th");
   }
   printf("Name = %s\n", name );
   printf("Description: %s\n", description );
}

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;
}