2022-01-23

WARNING: This article may be obsolete
This post was published in 2022-01-23. Obviously, expired content is less useful to users if it has already pasted its expiration date.

This article is categorized as "Garbage" . It should NEVER be appeared in your search engine's results.

重新复习C语言

参考资料

🔗 [C 语言教程 | 菜鸟教程] https://www.runoob.com/cprogramming/c-tutorial.html
🔗 [C语言程序设计 浙江大学：翁恺_哔哩哔哩_bilibili] https://www.bilibili.com/video/BV1Ls411w7rx
📖《C程序设计语言》
🔗 [你不见得会计算C字符串长度 - 掘金] https://juejin.cn/post/6844904073150332942

数据类型和范围

最基本的数据类型：

🔗 [C 数据类型 | 菜鸟教程] https://www.runoob.com/cprogramming/c-data-types.html

解释int范围：

浮点类型：

需要区分以下3种字符串初始化语句

char test[1000] = "012abc测试字符串";

char test[] = "012abc测试字符串";

char *test = "012abc测试字符串";

先写总结：

char test[1000];
// 一堆脏数据


char test[1000] = "";
// 会初始化出1000个'\0'


char test[1000] = "012abc测试字符串";
// 会初始化出一个长度为1000的空间，包含开头的"012abc测试字符串"以及一大堆0
// sizeof(test)=1000
// 可以使用strlen(test)找到正确的字符串长度: strlen(test)=21


char test[] = "012abc测试字符串";
// 只会初始化出长度为22的空间（21加上末尾的'\0'所以是22）
// sizeof(test)=22
// strlen(test)=21
// 允许修改字符串内容，比如test[0]='k'或者*(test+0)='k'


char *test = "012abc测试字符串";
// sizeof(test)=8，因为这是指针长度
// strlen(test)=21
// 不允许用任何方法修改里面的内容，比如*(test+1)='k'
// 会导致程序直接错误退出（gcc: Program returned: 139)
// 特别注意，上面这条特性并不是C语言的设计特性，而是编译器的处理，由操作系统提供“只读内存”的实现。
// 部分上古C语言编译器（比如DOS）可能会允许修改字符串的内容。

以下是一些程序：

#include<stdio.h>

int main(int argc, char const *argv[]) {

    char test[1000] = "012abc测试字符串";
    printf("%s\n", test);
    int i = 0;
    for (i = 0; i < 1000; i++) {
        printf("%c", test[i]);
    }
    printf("\n");
    for (i = 0; i < 1000; i++) {
        printf("%d,", test[i]);
    }
    return 0;
}

结果：

这里有必要提前解释一下后面出现的许多 0 ，这是因为我们的代码触发了C语言的“字符串初始化末尾添加\0”这样的操作。注意到下面这两句代码产生的数组空间是完全不一样的：

char arr[1000];
// 一堆脏数据

char arr[1000] = ""; 
// 全部都是\0

char arr[1000] = "abc";
// 除了开头的abc以外，剩下的全部都是\0

验证：

#include<stdio.h>

int main(int argc, char const *argv[]) {

    char arr[10];
    for (int i = 0; i < 10; i++) {
        printf("%d", arr[i]);
    }
    printf("\n");
    char arr2[10] = "";
    for (int i = 0; i < 10; i++) {
        printf("%d", arr2[i]);
    }
    return 0;
}

得到的结果：

回到之前的代码，修改第5行的内容为 char test[] = "012abc测试字符串" ，程序如下：

#include<stdio.h>

int main(int argc, char const *argv[]) {

    char test[] = "012abc测试字符串"; //修改了这一行
    printf("%s\n", test);
    int i = 0;
    for (i = 0; i < 1000; i++) {
        printf("%c", test[i]);
    }
    printf("\n");
    for (i = 0; i < 1000; i++) {
        printf("%d,", test[i]);
    }
    printf("\n");
    return 0;
}

得到这个结果也很合理，因为我们并没有初始化1000这么大的数组空间，所以到了后面for循环打印出来的内容都是超出范围的脏数据。

类似地，第5行改为 char *test = "012abc测试字符串"; 也会出现类似结果.

最后再来讨论一下字符串长度的获取方式，尤其需要注意下面的代码中，获取 int test3[1000] 真实字符串长度的方式（移动指针寻找\0或者使用 strlen() ）：

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

int main(int argc, char const *argv[]) {

    char *test = "012abc测试字符串";
    printf("%lu\n", sizeof(test));
    // 8，因为这是指针地址的长度
    char test2[] = "012abc测试字符串";
    printf("%lu\n", sizeof(test2));
    // 22，因为sizeof()是compile time function
    char test3[1000] = "012abc测试字符串";
    printf("%lu\n", sizeof(test3));
    // 1000
    int len = 0;
    char *addr = test3;
    while (*(addr + len) != '\0') len++;
    printf("字符串长度：%d\n", len);
    // 方法1：通过移动指针寻找'\0'判断长度
    // 字符串长度：21，因为没有把'\0'计算在内
    printf("strlen: %lu\n", strlen(test3));
    // 方法2：直接使用strlen()
    // strlen: 21
}

（当然，这不可避免地又扯出了另一个中文字符长度的问题，先放在一边）

继续处理之前的问题，🔗 [你不见得会计算C字符串长度 - 掘金] https://juejin.cn/post/6844904073150332942

这里提到了

再结合🔗 [c - What is the difference between char s[] and char *s? - Stack Overflow] https://stackoverflow.com/questions/1704407/what-is-the-difference-between-char-s-and-char-s

总结：

sizeof和strlen

部分内容已经在上一个目录里面提到了。

对应程序：

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

int main(int argc, char const *argv[]) {

    char greeting[] = {'h', 'e', 'l', 'l', 'o'};
    printf("%ld\n", sizeof(greeting));
    printf("%ld\n", strlen(greeting));

    char greeting2[] = {'h', 'e', 'l', 'l', 'o', '\0'};
    printf("%ld\n", sizeof(greeting2));
    printf("%ld\n", strlen(greeting2));

    return 0;
}

结果：

5
11 // 这个结果是不确定的
6
5

其中，printf  strlen(greeting) 的结果是不固定的，不同环境下得到的结果可能都会不一样，这是因为我们没有给字符串数组末尾手动添加\0，这样会导致strlen()找不到正确的字符串结尾。

size_t类型

好像暂时理解起来有些困难：🔗 [size_t 这个类型的意义是什么？ - 知乎] https://www.zhihu.com/question/24773728

const

malloc和calloc

malloc和calloc的区别：calloc() 会 强制把分配得到的空间都统一初始化为0，而malloc() 不会 。但现实编写程序的过程中，我们仍然会发现很多时候malloc()获取的空间也是一堆初始化的0，注意这并不是malloc()导致的，而是操作系统的行为导致的。见：🔗 [c - Why does malloc initialize the values to 0 in gcc? - Stack Overflow] https://stackoverflow.com/questions/8029584/why-does-malloc-initialize-the-values-to-0-in-gcc

此外还有用法上的区别：

int *arr = (int *) malloc(10 * sizeof(int));
// malloc只需要传入一个参数


int *arr = (int *) calloc(10, sizeof(int));
// calloc需要传入2个参数：分配的元素个数，元素的大小

定义：

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

int main(int argc, char const *argv[]) {

    int size = 10;
    int i;
    char *str = (char *) malloc(size);
    str[0] = 'a';
    str[1] = 'b';
    str[2] = 'c';
    for (i = 0; i < size; i++) {
        printf("%c", str[i]);
    }
    printf("\n");
    for (i = 0; i < strlen(str); i++) {
        printf("%c", str[i]);
    }
    printf("\n");
    for (i = 0; i < sizeof(str); i++) {
        printf("%c", str[i]);
    }
    printf("\n");

    free(str);


    return 0;
}

结果：

abc
abc
abc

看起来和本文前面的 char *str="abc"; // 不可修改str的值 有些冲突，当然其实并不冲突：

🔗 [c - When to use malloc for char pointers - Stack Overflow] https://stackoverflow.com/questions/1788655/when-to-use-malloc-for-char-pointers

另一个小总结：

对这个小总结的代码验证：

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

int main(int argc, char const *argv[]) {

    char str[100];
    strcpy(str, "something");
    printf("%s\n", str);
    /*
     * 以下代码都会报错
    char str2[];
    strcpy(str2, "something else");
    printf("%s\n", str2);
     
    char str3[5];
    strcpy(str3, "something");
    printf("%s\n", str3);
     */

    return 0;
}

结果：

something

free

经常和malloc(), calloc()搭配使用。

int *arr = (int *) malloc(sizeof(int) * 10);
free(arr);

但我们有的时候会发现一个问题：

假设我们现在用 int *arr = (int *) malloc(sizeof(int) * 10) 语句申请了一块长度为10的int数组空间，我们只得到了数组的头指针。也就是说，在后续的代码里，如果我们“忘记”了申请数组的长度10，我们理论上就没有什么合法的办法来获取这个数字“10”了。但使用free()来释放空间的时候，我们发现free()并不需要我们提供数组的长度（甚至不接受int size这样的参数），这看起来似乎非常反直觉。它怎么就知道我们需要释放多少空间？

这几设计到复杂的内存分配器的实现机制了，比如：

详细内容见：🔗 [free()函数如何知道要释放的空间大小？ - 知乎] https://www.zhihu.com/question/302440083

memcpy

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

void case1();

void case2();

void case1() {
    char dest[] = "abcdefg";
    char src[] = "***";
    printf("Before: %s\n", dest);
    memcpy(dest, src, strlen(src));
    printf("After: %s\n", dest);
}

void case2() {
    char dest[] = "abcdefg";
    char src[] = "***";
    printf("Before: %s\n", dest);
    memcpy(dest, src, strlen(src) + 1); // 复制了'\0'过去，所以printf会提前结束
    printf("After: %s\n", dest);
}

int main(int argc, char const *argv[]) {

    printf("Case 1: \n");
    case1();
    printf("\nCase 2: \n");
    case2();

    return 0;
}

结果：

Case 1:
Before: abcdefg
After: ***defg

Case 2:
Before: abcdefg
After: ***

内存空间分配（stack, heap, static等）

比想象中要复杂难学一些（尤其是涉及到对godbolt.org assembly语句的学习），暂时先学这么多吧：

🔗 [C语言：内存分配 - 知乎] https://zhuanlan.zhihu.com/p/52125577