2022-01-26

WARNING: This article may be obsolete
This post was published in 2022-01-26. 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语言

函数的声明

基本规则1：需要在main函数前定义，或者在main函数前声明

基本规则2：函数的定义和函数的声明需要保持一致

一个有趣的问题

注意这段代码：

#include<stdio.h>

void print1();


int main(int argc, char const *argv[]) {
    print1(1.1);
    return 0;
}

void print1(float a){
    printf("print1");
}

当然这段代码是会报错的：

但是如果对第7, 11行进行修改：

#include<stdio.h>

void print1();


int main(int argc, char const *argv[]) {
    print1(1);     // 修改了这里
    return 0;
}

void print1(int a){     // 修改了这里
    printf("print1");
}

就不会报错，得到：

print1

（暂时先鸽了），目前在网上查到的最类似的问答：🔗 [c - Why does gcc allow arguments to be passed to a function defined to be with no arguments? - Stack Overflow] https://stackoverflow.com/questions/12643202/why-does-gcc-allow-arguments-to-be-passed-to-a-function-defined-to-be-with-no-ar

目前对这个问题的了解进度：

1，如果函数的参数没有特别声明为 void ，那么确实可以在定义中给若干个参数；

#include<stdio.h>

void print1();

int main(int argc, char const *argv[]) {
    print1(1, 2);
    return 0;
}

void print1(int a, int b, double c) {
    printf("%d\n", a);
    printf("%d", b);
}

1
2

2， void print1(float a) 为什么不行？因为调用这个函数的语句 print1(1.1); 传过去的实际上是double类型；

3，根据上一条，把 void print1(float a) 改为 void print1(double a) 是OK的；

4，但我还是想写 void print1(float a) ，能不能调用这个函数的时候使用 print1(1.1f) 或者 print1((float)1.1) ？是不可以的，它们最后还是会被强制转换为double类型，导致变量类型冲突。

当然，这样做真的没有什么实际意义，所有的功课都是在给C语言编译器的老旧兼容模式让路：🔗 [C function float argument takes different value inside the function - Stack Overflow] https://stackoverflow.com/questions/36833308/c-function-float-argument-takes-different-value-inside-the-function

指针、取地址、解引用、引用

引用符号：Reference operator   &  ，但并不是所有场景下都被视为reference operator .

解引用符号：de-reference operator   *  ，但并不是所有场景下都被视为de-reference operator .

关于int* p和int *p的写法：🔗 [C/C++ 里指针声明为什么通常不写成 int* ptr 而通常写成 int *ptr ? - 知乎] https://www.zhihu.com/question/52305847?rf=21136956

同时要注意：

如何正确理解

int v = 10;
int *p = &v;

 p 是指针；等号右边 &v 代表地址；

在 int *p = &v  的声明中，  * 不代表de-reference operator ，仅仅代表指针的声明。所以 不能 用这样的方法去推断："p代表指针，那么*p代表数值，但等号左边是数值等号右边是地址，不对怎么混乱了...".

所以还是  int* p = &v  这样的写法更容易懂一点。

#include<stdio.h>


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

    int v = 10, v2 = 100;
    int *p = &v;
    // 另一种理解：
    // int* p = &v;
    // p是一个指针，指向int v=10所在的地址; [*]是dereference operator，所以[*p]取得了[指针p所指向的地址的数值]
    printf("value of v is %d\n", *p);
    // value of v is 10
    printf("pointer p（指向v）指向的地址: %p\n\n", p);
    // pointer p（指向v）指向的地址: 0x7ffd51383c34

    // 把指针p指向的地址修改成了int v2=100的地址
    p = &v2;
    printf("value of v2 is %d\n", *p);
    // value of v2 is 100
    printf("pointer p（指向v2）指向的地址: %p\n\n", p);
    // pointer p（指向v2）指向的地址: 0x7ffd51383c30

    // 把指针p指向的地址（当前指向了int v2=100）里面的数值修改成了1000
    *p = 1000;
    printf("value of new p is %d\n", *p);
    // value of new p is 1000
    printf("pointer p（指向v2）指向的地址: %p\n", p);
    // pointer p（指向v2）指向的地址: 0x7ffd51383c30
    printf("value of v2 NOW is：%d\n", v2);
    // value of v2 NOW is：1000
    printf("value of v2，另一种写法：%d", *&v2);
    // value of v2，另一种写法：1000

    return 0;
}

value of v is 10
pointer p（指向v）指向的地址: 0x7ffd51383c34

value of v2 is 100
pointer p（指向v2）指向的地址: 0x7ffd51383c30

value of new p is 1000
pointer p（指向v2）指向的地址: 0x7ffd51383c30
value of v2 NOW is：1000
value of v2，另一种写法：1000

注意到第13行， *p = 1000; 这句话并没有改变指针p指向的地址。长时间写python导致我很容易搞错这一点。另外注意第16行输出的结果：p指向了v2的地址，改变了这个地址下的数值，所以变量v2的数值也会改变。

指针地址的救捞

我们都会写 int *p = & v 这样的语句，那么如果写成 int p = &v 呢？

#include<stdio.h>

int main(int argc, char const *argv[]) {
    int v = 10;
    int p = &v;  // 危险！
    printf("%d\n", p);
    // -762018736
    return 0;
}

可以看到，这段程序还是可以运行的，编译器也不会罢工。那么我们继续危险一步：

我们能不能从 int p 这个变量里捞出正确的指针呢？

使用int是不行的，下面的程序直接异常退出了，说明我们无法从int类型的变量里救捞出正确的指针地址：

#include<stdio.h>

int main(int argc, char const *argv[]) {
    int v = 10;
    int reverse = &v;
    int *save_me = (int *) reverse;  // 这一步捞出了一个错误的地址
    printf("save me: %d\n", *save_me);
    return 0;
}

//  segmentation fault  ./a.out

但我们仍不死心，还记得sizeof(指针)=8吗？可能是因为sizeof(int)=4不够用，我们也许可以试试sizeof(long)=8！

首先我们熟悉一下（64位环境）int, long 和 int指针 所占用的空间大小：

#include<stdio.h>

int main(int argc, char const *argv[]) {
    int v = 10;
    long l = 10;
    int *p = &v;
    printf("size of int: %lu\n", sizeof(v));
    // size of int: 4
    printf("size of pointer: %lu\n", sizeof(p));
    // size of pointer: 8
    printf("size of long: %lu\n", sizeof(l));
    // size of long: 8
    return 0;
}

然后我们尝试用long类型去救捞指针地址：

#include<stdio.h>

int main(int argc, char const *argv[]) {
    int v = 999;
    long reverse = &v;
    int *save_me = (int *) reverse;
    printf("save me: %d\n", *save_me);
    // 999
    return 0;
}

野鸡方法到此为止，接下来是官方推荐的做法：使用 uintptr_t ：

#include<stdio.h>

int main(int argc, char const *argv[]) {
    int v = 999;
    uintptr_t reverse = (uintptr_t) &v;
    int *save_me = (int *) reverse;
    printf("save me: %d\n", *save_me);
    // 999
    return 0;
}

事实上， uintptr_t 这个东西就是 unsigned long . 头文件

社区对这个话题的其他讨论：🔗 [c++ - converting int to pointer - Stack Overflow] https://stackoverflow.com/questions/9212219/converting-int-to-pointer

参数传递

一个最简单的例子：

#include<stdio.h>

void helper(int *p) {
    printf("p是指针，指向了%d\n", *p);
    // p是指针，指向了10
}

int main(int argc, char const *argv[]) {
    int v = 10;
    int *p = &v;
    helper(p);
    return 0;
}

同样，使用 void helper(int* p) 这样的方法理解参数传递更容易懂一些。

特别注意到C++独有的 reference parameter 写法，这是因为 C语言只支持pointers，不支持references  .

#include <iostream>

void increment(int &x)
{
    x++;
}

int main()
{
    int value = 10;
    std::cout << "Before increment: value = " << value << std::endl;
    // Before increment: value = 10

    increment(value);
    std::cout << "After increment: value = " << value << std::endl;
    // Before increment: value = 11

    return 0;
}

extern关键字

准备两个文件，1.c和2.c：

1.c:

// 1.c
#include<stdio.h>

int num = 10001;

void forfun() {
    printf("File 1.c: void forfun()");
}

2.c:

// 2.c
#include<stdio.h>
#include"1.c"

extern int num;

extern void forfun();

int main() {
    printf("In file 2.c, display variable num: %d\n", num);
    forfun();
    return 0;
}

编译2.c，运行结果：

In file 2.c, display variable num: 10001
File 1.c: void forfun()

后续阅读材料：🔗 [C语言正确使用extern关键字_xingjiarong的专栏-CSDN博客_c extern] https://blog.csdn.net/xingjiarong/article/details/47656339

static关键字

简单介绍：

static的一个重要应用：

并发，并行，串行，异步，同步，多线程，进程，线程

并发和并行

🔗 [并发与并行的区别是什么？ - 知乎] https://www.zhihu.com/question/33515481

串行和并行

（注：目前暂时不是很赞同下面这张图的最后一句话）

异步，多线程和并行

🔗 [异步，多线程和并行的区别？ - 知乎] https://www.zhihu.com/question/28550867

线程和进程

多线程和多进程

🔗 [多线程与多进程的思考 - 知乎] https://zhuanlan.zhihu.com/p/45233772

🔗 [多线程还是多进程的选择及区别 - 贺大卫 - 博客园] https://www.cnblogs.com/virusolf/p/5458325.html