C语言程序设计期末总结
发表更新28 分钟读完 (大约4165个字)

C语言程序设计期末总结

常用知识点总结

目录

常见库函数

  1. 字符处理函数（在 <ctype.h> 头文件中）
  • isalpha(int ch)： 检查字符是否是字母。
  • isdigit(int ch)： 检查字符是否是数字。
  • isalnum(int ch)： 检查字符是否是字母或数字。
  • islower(int ch)： 检查字符是否是小写字母。
  • isupper(int ch)： 检查字符是否是大写字母。
  • tolower(int ch)： 将字符转换为小写形式。
  • toupper(int ch)： 将字符转换为大写形式。
  1. 字符串处理函数（在 <string.h> 头文件中）
  • strlen(const char *str)： 返回字符串的长度。
  • strcpy(char *dest, const char *src)： 将一个字符串复制到另一个字符串。
  • strcat(char *dest, const char *src)： 将一个字符串追加到另一个字符串。
  • strcmp(const char *str1, const char *str2)： 比较两个字符串。
  • strncmp(const char *str1, const char *str2, size_t n)： 比较两个字符串的前 n 个字符。
  • strchr(const char *str, int ch)： 在字符串中查找字符第一次出现的位置。
  • strstr(const char *haystack, const char *needle)： 在字符串中查找子字符串的第一次出现位置。
  1. 数学函数（在 <math.h> 头文件中）
  • sqrt(double x)： 返回 x 的平方根。
  • pow(double x, double y)： 返回 x 的 y 次幂。
  • fabs(double x)： 返回 x 的绝对值。
  • ceil(double x)： 返回不小于 x 的最小整数值。
  • floor(double x)： 返回不大于 x 的最大整数值。
  • sin(double x)： 返回 x 的正弦值。
  • cos(double x)： 返回 x 的余弦值。
  • tan(double x)： 返回 x 的正切值。
  1. 输入/输出函数（在 <stdio.h> 头文件中）
  • printf(const char *format, ...)： 格式化输出到标准输出。
  • scanf(const char *format, ...)： 格式化输入从标准输入。
  • fgets(char *str, int n, FILE *stream)： 从文件流中读取一行。
  • fputs(const char *str, FILE *stream)： 将字符串写入文件流。
  • fscanf(FILE *stream, const char *format, ...)： 从文件流中格式化输入。
  • fprintf(FILE *stream, const char *format, ...)： 将格式化输出写入文件流。
  1. 内存分配函数（在 <stdlib.h> 头文件中）
  • qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *))： 对数组进行快速排序。
  • malloc(size_t size)： 分配指定字节数的内存。
  • calloc(size_t num, size_t size)： 分配指定数量和大小的内存块，并将其初始化为零。
  • realloc(void *ptr, size_t size)： 更改之前分配的内存块的大小。
  • free(void *ptr)： 释放之前分配的内存块。

这只是一小部分标准库函数。C 语言标准库提供了许多其他有用的函数，用于处理日期和时间、动态分配内存等。标准库函数的完整列表和详细信息可以在相关的 C 语言标准文档中找到。

switch用法

1
2
3
4
5
6
7
8
9
10
11
switch(m)
{
    case 1: case 3: case 5:
    printf("yes");
    break;
    case 4:case 6:
    printf("no");
    break;
    default:
    break;
}

输入数值后输入字符串

1
2
scanf("%d\n",&n);
gets(text);

fgets用法

  • 结束使用NULL而非EOF(当 fgets 遇到文件结束时，它会返回一个空指针 (NULL))
  • strcspn 函数返回字符串中不包含指定字符集合中任何字符的第一个位置（即字符串中不包含这些字符的部分的长度）
  • 用scanf读取字符串时，%s在遇到空格、制表符或换行符时会停止读取。如果用户输入包含空格，只会读取第一个单词
    1
    2
    3
    4
    5
    6
    7
    fgets(myString, sizeof(myString), stdin);

    // 去除末尾的换行符
    myString[strcspn(myString, "\n")] = '\0';

    // 输出处理后的字符串
    printf("Processed string: %s\n", myString);

strstr用法

需要注意的是，strstr 是区分大小写的。如果你需要进行大小写不敏感的查找，可以考虑使用其他函数，比如 strcasestr（不是标准C函数，但在一些系统中可能提供）或手动转换字符串为小写/大写后再使用 strstr。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
#include <string.h>

int main() {
    const char *haystack = "Hello, World!";
    const char *needle = "World";

    // 在 haystack 中查找 needle
    char *result = strstr(haystack, needle);

    if (result != NULL) {
        printf("'%s' found at position %ld in '%s'\n", needle, result - haystack, haystack);
    } else {
        printf("'%s' not found in '%s'\n", needle, haystack);
    }

    return 0;
}

strcmp用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <string.h>

int main() {
    const char *str1 = "apple";
    const char *str2 = "banana";

    int result = strcmp(str1, str2);

    if (result < 0) {
        printf("%s is less than %s\n", str1, str2);
    } else if (result == 0) {
        printf("%s is equal to %s\n", str1, str2);
    } else {
        printf("%s is greater than %s\n", str1, str2);
    }

    return 0;
}

判断字母大小写

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <ctype.h>

int main() {
    char ch = 'A';

    if (isupper(ch)) {
        printf("%c is an uppercase letter.\n", ch);
    } else {
        printf("%c is not an uppercase letter.\n", ch);
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <ctype.h>

int main() {
    char ch = 'a';

    if (islower(ch)) {
        printf("%c is a lowercase letter.\n", ch);
    } else {
        printf("%c is not a lowercase letter.\n", ch);
    }

    return 0;
}

sscan & sprintf用法

sscanf：用于从字符串中按照指定的格式读取数据。

  • 函数原型：int sscanf(const char *str, const char *format, ...);
    参数：
  • str：要读取的字符串。
  • format：格式说明符，指定了要读取的数据的类型和格式。
  • 后续的参数：指向变量的指针，用于存储读取到的数据。
  • 返回值：成功读取并赋值的参数个数。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    #include <stdio.h>

    int main() {
        char input[] = "John 25 1.75";
        char name[20];
        int age;
        float height;

        // 从字符串 input 中按照格式读取数据
        int result = sscanf(input, "%s %d %f", name, &age, &height);

        if (result == 3) {
            printf("Name: %s\n", name);
            printf("Age: %d\n", age);
            printf("Height: %.2f\n", height);
        } else {
            printf("Failed to read data from the string.\n");
        }

        return 0;
    }
    sprintf：用于按照指定的格式将数据写入字符串。
  • 函数原型：int sprintf(char *str, const char *format, ...);
    参数：
  • str：目标字符串，用于存储格式化后的数据。
  • format：格式说明符，指定了要写入的数据的类型和格式。
  • 后续的参数：要写入的数据。
  • 返回值：写入到字符串中的字符数（不包括终止符 \0）。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    #include <stdio.h>

    int main() {
        char buffer[50];
        int num = 42;
        float pi = 3.14159;

        // 将格式化的数据写入字符串 buffer
        int result = sprintf(buffer, "The number is %d and the value of pi is %.2f", num, pi);

        if (result > 0) {
            // 输出写入的字符串
            printf("Formatted string: %s\n", buffer);
        } else {
            printf("Error in sprintf function.\n");
        }

        return 0;
    }

取两个数中较大值或较小值

1
2
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))

qsort用法

这个函数接受四个参数：

  • base：指向待排序数组的指针。
  • nmemb：数组中元素的个数。
  • size：每个元素的大小（以字节为单位）。
  • compar：比较函数的指针，用于定义元素之间的比较规则。

比较函数 compar 应该返回一个整数：

  • 如果第一个参数小于第二个参数，返回负数。
  • 如果第一个参数等于第二个参数，返回零。
  • 如果第一个参数大于第二个参数，返回正数。
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    #include <stdio.h>
    #include <stdlib.h>

    // 比较函数，用于指定整数的比较规则
    int compareIntegers(const void *a, const void *b) {
        return (*(int *)a - *(int *)b);//交换a和b实现降序排列
    }

    int main() {
        int numbers[] = {5, 2, 9, 1, 5, 6};

        size_t size = sizeof(numbers) / sizeof(numbers[0]);

        // 使用 qsort 对整数数组进行排序
        qsort(numbers, size, sizeof(numbers[0]), compareIntegers);

        // 输出排序后的数组
        for (size_t i = 0; i < size; ++i) {
            printf("%d ", numbers[i]);
        }
        printf("\n");

        return 0;
    }

判断一个十进制数的二进制表示中有几个“ 1 ”

1
2
3
4
5
6
7
8
9
10
11
12
13
int countOnesInBinary(int num) {
    int count = 0;

    // 遍历二进制表示中的每一位
    while (num != 0) {
        if (num % 2 == 1) {
            count++;
        }
        num /= 2;
    }

    return count;
}

找最大公约数

1
2
3
4
5
6
7
8
int findGCD(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

二分法查找数组中目标数值的位置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include <stdio.h>

// 函数声明
int binarySearch(int arr[], int low, int high, int target);

int main() {
    int size;

    // 从用户输入获取数组大小
    printf("Enter the size of the sorted array: ");
    scanf("%d", &size);

    int arr[size];

    // 从用户输入获取已排序的数组
    printf("Enter the sorted array elements:\n");
    for (int i = 0; i < size; i++) {
        scanf("%d", &arr[i]);
    }

    int target;

    // 从用户输入获取要查找的目标值
    printf("Enter the target value to search: ");
    scanf("%d", &target);

    // 调用二分查找函数
    int result = binarySearch(arr, 0, size - 1, target);

    // 输出查找结果
    if (result != -1) {
        printf("Target value %d found at index %d.\n", target, result);
    } else {
        printf("Target value %d not found in the array.\n", target);
    }

    return 0;
}

// 二分查找函数定义
int binarySearch(int arr[], int low, int high, int target) {
    while (low <= high) {
        int mid = low + (high - low) / 2;

        // 检查中间元素是否是目标值
        if (arr[mid] == target) {
            return mid;
        }

        // 如果目标值在左半部分，则更新 high
        if (arr[mid] > target) {
            high = mid - 1;
        }

        // 如果目标值在右半部分，则更新 low
        else {
            low = mid + 1;
        }
    }

    // 如果目标值不在数组中，返回 -1
    return -1;
}

位运算

1. 按位与（AND）：&

  • 将两个操作数的对应位进行与操作，结果位为1当且仅当两个操作数对应位都为1。

2. 按位或（OR）：|

  • 将两个操作数的对应位进行或操作，结果位为1当且仅当两个操作数对应位至少有一个为1。

3. 按位异或（XOR）：^

  • 将两个操作数的对应位进行异或操作，结果位为1当且仅当两个操作数对应位不相等。

4. 按位取反（NOT）：~

  • 对操作数的每个位取反，即将0变为1，将1变为0。

5. 左移：<<

  • 将操作数的所有位向左移动指定的位数，右侧补零。

6. 右移：>>

  • 将操作数的所有位向右移动指定的位数，左侧补符号位（对于有符号整数）或者补零（对于无符号整数）。

占位符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <stdio.h>

int main() {
    int integerVar = 42;
    float floatVar = 3.14;
    char charVar = 'A';
    char stringVar[] = "Hello, World!";
    int *pointerVar = &integerVar;

    // 使用占位符输出变量的值
    printf("Integer: %d\n", integerVar);
    printf("Float: %f\n", floatVar);
    printf("Char: %c\n", charVar);
    printf("String: %s\n", stringVar);
    printf("Pointer: %p\n", pointerVar);
    
    // 使用 %x 输出整数的十六进制形式
    printf("Integer in Hexadecimal: %x\n", integerVar);

    return 0;
}

数据类型及范围

整型数据类型

  • int： 整数类型，通常占用4个字节，表示整数值。范围约为 -2,147,483,648 到 2,147,483,647。
  • char： 字符类型，占用1个字节，表示单个字符的ASCII码值。范围为 0 到 255 或 -128 到 127（有符号/无符号）。
  • short： 短整数类型，通常占用2个字节，表示较小范围的整数值。范围约为 -32,768 到 32,767。
  • long： 长整数类型，占用4或8个字节，表示较大范围的整数值。范围约为 -2,147,483,648 到 2,147,483,647（32位系统）或 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807（64位系统）。
  • long long： 更长的整数类型，占用8个字节，表示更大范围的整数值。范围约为 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807。

浮点型数据类型

  • float： 单精度浮点数类型，通常占用4个字节，表示小数值。范围约为 1.17549435e-38 到 3.40282347e+38。
  • double： 双精度浮点数类型，通常占用8个字节，表示更高精度的小数值。范围约为 2.2250738585072014e-308 到 1.7976931348623158e+308。

字符型数据类型

  • char： 字符类型，占用1个字节，表示单个字符的ASCII码值。范围为 0 到 255 或 -128 到 127（有符号/无符号）。

指针类型

  • int*： 指向整数的指针类型。
  • float*： 指向浮点数的指针类型。
  • char*： 指向字符的指针类型。

数组类型

  • int[]： 整数数组类型。
  • float[]： 浮点数数组类型。
  • char[]： 字符数组类型。

其他类型

  • void： 表示没有数据类型。
  • enum： 枚举类型，用于定义一组命名的整数常量。

这些数据类型和范围的信息对于正确使用和存储数据至关重要。请注意，数据范围可能会因编译器和操作系统的不同而有所不同。

转义符

在C语言中，转义符（Escape Characters）以反斜杠（\）开头，用于在字符串常量中表示一些特殊字符或控制字符。以下是一些常见的C语言转义符：

  1. \\n： 换行符（New Line）

    • 示例：printf("Hello\\nWorld");

  2. \\t： 水平制表符（Tab）

    • 示例：printf("Name:\\tJohn");

  3. \\r： 回车符（Carriage Return）

    • 示例：printf("One\\rTwo");

  4. \\b： 退格符（Backspace）

    • 示例：printf("Back\\bSpace");

  5. \\f： 换页符（Form Feed）

    • 示例：printf("Page 1\\fPage 2");

  6. \\\\： 反斜杠自身

    • 示例：printf("This is a backslash: \\\\\\");

  7. \\\"： 双引号自身

    • 示例：printf("He said, \\"Hello!\\"");

  8. \\\'： 单引号自身

  9. \\0： 空字符（Null）

    • 示例：字符串结尾的空字符 '\\0' 是C语言字符串的终止符。

  10. \0 到 \7：八进制转义字符

  • 示例：printf("Octal representation: \\115");（表示 'M'）

  1. \x0 到 \xFF： 十六进制转义字符

    • 示例：printf("Hex representation: \\x4A");（表示 'J'）

递归函数计算阶乘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>

// 递归函数计算阶乘
unsigned long long factorial(int n) {
    // 基本情况：当 n 为 0 或 1 时，阶乘为 1
    if (n == 0 || n == 1) {
        return 1;
    } else {
        // 递归情况：n 的阶乘等于 n 乘以 (n-1) 的阶乘
        return n * factorial(n - 1);
    }
}

int main() {
    int num = 5;

    // 调用递归函数计算阶乘
    unsigned long long result = factorial(num);

    // 输出结果
    printf("Factorial of %d = %llu\n", num, result);

    return 0;
}

判断质数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <stdio.h>

// 判断一个数是否为质数
int isPrime(int number) {
    if (number <= 1) {
        return 0; // 1和负数不是质数
    }

    for (int i = 2; i * i <= number; ++i) {
        if (number % i == 0) {
            return 0; // 能被整除，不是质数
        }
    }

    return 1; // 不能被整除，是质数
}

int main() {
    int num;

    // 从用户输入获取一个整数
    printf("Enter a positive integer: ");
    scanf("%d", &num);

    // 调用函数判断是否为质数并输出结果
    if (isPrime(num)) {
        printf("%d is a prime number.\n", num);
    } else {
        printf("%d is not a prime number.\n", num);
    }

    return 0;
}

冒泡排序

升序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <stdio.h>

// 冒泡排序函数（升序）
void bubbleSortAsc(int arr[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        for (int j = 0; j < n - i - 1; ++j) {
            // 如果当前元素大于下一个元素，交换它们
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// 打印数组元素
void printArray(int arr[], int size) {
    for (int i = 0; i < size; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    // 输出排序前的数组
    printf("Unsorted array: ");
    printArray(arr, n);

    // 调用冒泡排序函数（升序）
    bubbleSortAsc(arr, n);

    // 输出排序后的数组
    printf("Sorted array (ascending): ");
    printArray(arr, n);

    return 0;
}

降序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <stdio.h>

// 冒泡排序函数（降序）
void bubbleSortDesc(int arr[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        for (int j = 0; j < n - i - 1; ++j) {
            // 如果当前元素小于下一个元素，交换它们
            if (arr[j] < arr[j + 1]) {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

// 打印数组元素
void printArray(int arr[], int size) {
    for (int i = 0; i < size; ++i) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    // 输出排序前的数组
    printf("Unsorted array: ");
    printArray(arr, n);

    // 调用冒泡排序函数（降序）
    bubbleSortDesc(arr, n);

    // 输出排序后的数组
    printf("Sorted array (descending): ");
    printArray(arr, n);

    return 0;
}

大小写转换函数(toupper & tolower)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <ctype.h>

int main() {
    char ch = 'A';
    
    // 使用 tolower 将字符转换为小写形式
    char lowercaseCh = tolower(ch);

    printf("Original character: %c\n", ch);
    printf("Lowercase character: %c\n", lowercaseCh);

    return 0;
}

C语言程序设计期末总结

https://lhy0424.top/2024/07/31/final_summary/

作者

Az

发布于

2024-07-31

更新于

2024-07-31

许可协议

关注我

链接

订阅更新

follow.it

最新文章

归档

×