指针、函数

1、const （相当于java 的 final ）

注意：const 放到谁的前面，谁不可改变。所以，<一般const的语法需要从右往左看，const修饰谁，谁就不可变>

const char *p;  // 修饰的是 char 。所以 p 的内容不可以修改，但是可以把p指向一个新的 char 的内容地址
char const *p1; // 跟上面的 没有 区别。因为const 不可以修饰 * 符号，只能修饰char
char * const p2;  // p2不可以改变，但是p2是一个指针，所以p2对应的地址中的 内容可以改变
const char * const p3； // p3的地址不可以改变，p3 的地址中的 char 内容也不可以改变

2、多级指针

指向指针的指针
一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。
**存放的是其他指针的地址，所以下面代码中 i 的地址和 j 的内容是一样的 **

    int a = 10;
    int *i = &a;
    int **j = &i;
    // 解引用
    printf("i的地址是 %#x, j中存放的地址是 %#x\n", i, *j);
    printf("j的地址是 %#x\n", j);
    printf("j 解引用 数据是 %d\n", **j);
结果：
i的地址是 0xe129a528, j中存放的地址是 0xe129a528
j的地址是 0xe129a520
j 解引用 数据是 10

3、函数

函数参数

传值调用

    把参数的值 **复制** 给函数的形式参数。修改形参不会影响实参

引用调用

    如果形参为指向 **实参地址的指针** ，可以通过指针修改 实参。
    所以参数为指针的原因就是 为了 可以 修改 实参。不然得通过返回值，再次赋值给实参。

C 函数参数 ～ 与 java 的区别

public void addition_isCorrect() {
        int a = 10;
        String str = "abcde";
        Bean bean = new Bean();
        change(a, str, bean);
        System.out.println(str + "  " + a + "  " + bean);
    }
    public void change(int a, String str, Bean bean) {
        a = 12;
        str = "1344";
        bean.age = 123;
        bean.name = "345678";
    }
    class Bean{
        int age = 100;
        String name = "majie";
        @Override
        public String toString() {
            return "Bean{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
    结果: abcde  10  Bean{age=123, name='345678'}
    int 和 String 没有修改（传值调用）， Bean 类却修改了其 属性的值（类似引用调用）。

上面是java 的参数相关的代码，下面是c的

void add(int a, int *b) {
    printf("a 的值是 %d, b 的值是一个地址 %#x \n", a, b);
    *b = a + *b;
    printf("和值是 %d \n", *b);
}

void change(int **b) {
    int ad = 1001;
    // 因为b是指针的指针，所以*b中是地址
    *b = &ad;
// **b 表示的就是 对应的地址中的数据
    **b = ad;
}

int main(){
    int c = 12;
    int *f = &c;
    printf("c 的值是 %d, f 的值是一个地址 %#x \n", c, f);
    printf("add 调用之前 *f 是 %d \n", *f);
    add(c, f);
    printf("当前的c是 %d, 当前的 *f 是 %d \n", c, *f);

    // 多级指针的意义 此时 *f 的内容是 24， 将 f 这个变量的地址，传递给 change 函数
    change(&f);
    printf("当前的 *f 是 %d \n", *f);
    return 0；
}
结果：
c 的值是 12, f 的值是一个地址 0xe0c23528 
add 调用之前 *f 是 12 
a 的值是 12, b 的值是一个地址 0xe0c23528 
// add 方法中 f 和 b 是同一个地址，同时在add 方法中修改了 （*f） 的值
和值是 24 
当前的c是 24, 当前的 *f 是 24 
// 在change 方法中再次传入 指针 f 的地址，同时修改了 指针f  <指向的地址>，所以变成了 1001
当前的 *f 是 1001 

c中也有可变参数，使用的是 ... 需要引入 #include<stdarg.h>

4、函数指针 ~ 指向函数的指针变量

C中可以接收一个函数作为参数

/**
 *  void (*p)(char *) 表示这个参数是一个函数
 *  void 表示 返回值
 *  char* 表示参数
 *  p 变量表示这个函数
 *  （*p） 表示 指向这个函数的 指针
*/
void say(void (*p)(char*), char *msg) {
    p(msg);
}

void dayin(char *msg) {
    printf("%s\n", msg);
}

int main()
{
    // 声明一个函数指针的变量，他指向了一个函数 （这个变量的定义类别要跟这个函数一致）
    void (*functionP)(char*) = dayin;
    say(functionP, "niubi");
    retutrn 0;
}

//typedef 创建别名 由编译器执行解释
typedef void(*Callback)(int);
typedef long long int64_t; int64_t 就可以作为一个 类或者属性来使用。 相当于 long long 了

int number(int num) {
    num = 1001 + num;
    return num;
}

// 有点类似于 java 的回调或者接口
typedef int(*Callback)(int);   // 此时Callback 就是一个别名，像类一样，

int main() {
    Callback call = number;
    printf("num=%d\n", call(3));
    return 0;
}