当前位置:   article > 正文

学习C语言 第十九天

学习C语言 第十九天

第一项

C 内存管理

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

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

注意: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;
}

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小惠珠哦/article/detail/1015866
推荐阅读
相关标签
  

闽ICP备14008679号