C 内存和字符

1.先记录下函数指针

int plus(int a, int b){
    return a + b;
}
int plus2(int *a, int *b){
    return *a + *b;
}

int minus(char *a, char *b){
    return 0;
}
int pp(char *a, char *b){
    return *a;
}
int main(){
    //函数指针
    int(*cal)(int a, int b);
    cal = plus;
    int result;
    result = cal(3, 5);
    printf("%d\n", result);
    printf("plus: %#x\n", &plus);

    //函数指针
    int(*cal4)(int *a, int *b);
    int aa = 90, bb = 8;
    cal4 = plus2;
    result = cal4(&aa,&bb);
    printf("%d\n", result);
    printf("plus2: %#x\n", &plus2);
    //函数指针
    int c = 5;
    int d = 1;
    int(*cal2)(void *a, void *b);
    //c中强制类型转换
    //void  类似Java中的Object类型
    //void *-->>int(*) /char(*)/float(*)
    //void 是c中的 面向对象的思想
    cal2 = (int(*)(void *, void *))plus2;
    result = cal2(&c, &d);
    printf("result2= %d\n", result);
    //函数指针
    int (*cal3)(void *a, void *b);
    cal3 = (int(*)(void *, void *))minus;
    result = cal3(&c, &d);
    printf("result3= %d\n", result);

    //一个返回值是int * 的函数
    int * p(int a,int b);

    system("pause");
    return 0;
}

总：函数指针，将函数对应方法地址，指针是对地址操作，所以函数指针实质也是对地址的操作。

2.//=========内存分配=========

//内存
//3区
//程序区和程序二进制文件
//静态分配：全局变量和静态变量
//动态存储区
//1)堆区：用于程序动态分配  
//2)栈区：编译器自动分配，编译器自动申请和释放2M

//const 和Java中的static 类似
int const a = 100;
int  main(){
    //40M 的数组
    //栈溢出
    //int a[1024 * 1024 * 10];
    //40M 手动分配  还有7M系统分配的
    int *a = (int *)malloc(sizeof(int)* 1024 * 1024 * 10);
    system("pause");
    return 0;
}

=======================

void mem(){ 
    //malloc 用于申请内存 一次性连续
    int *a = (int *)malloc(sizeof(int)* 1024 * 1024 * 5);
}
int main(){
    int t = 100;
    int a[10];
    //大于1 为true 小于0 是false 0就是0
    while (1){
        mem();
        Sleep(2000);
    }

    system("pause");
    return 0;
}

==================

int main(){
    //申请count个   大小为size的连续空间（分段连续）
    //将内存初始化为0
    
    //是单片机编程时候的，像空调的内存会非常小
    int *b = (int *)calloc(4, 100 * sizeof(int));
    if (b == NULL){
        printf("内存不够\n");
    }

    system("pause");
    return 0;
}

==================

//内存泄漏 
int main(){
    int *a = (int *)malloc(sizeof(int)* 1024 * 1024*5);
    a[0] = 10; 
    printf("%#x\n", a);
    //不能重复释放  会立刻回收
    //Java gc  oom  内存不会立刻回收
    free(a);
    //free(a);重复释放会报错
    printf("%#x\n", a);
    //不制成空的话，现在还用空做逻辑会出错
    if (a != NULL){
        printf("程序现在还能执行\n");
    }

    a = NULL;
    printf("%#x\n", a);
    if (a != NULL){
        printf("程序现在还能执行么\n");
    }
    system("pause");
    return 0;
}

总：动态分配的，malloc 是最常用的内存申请函数；当然calloc和relloc都是内存申请，没有malloc普遍,malloc和calloc的区别，malloc申请是一段连续的内存，calloc申请的是几段连续的内存，申请完还初始化赋值，申请完地址，一定要free 掉，还要制成NULL，这样地址的引用和内存才会被完全清理掉。

===========

3.字符串  
//c 语言里面没有string 
int main(){
    //\0 就结束了
    char ch1[10] = {'c','h','i','n','a','\0','a'};
    printf("%s\n", ch1);
    //如果没有\0就会乱码
    char ch2[] = { 'c', 'h', 'i', 'n', 'a', '\0' };
    printf("%s\n", ch2);
    //常量申请的是地址 这个时候可以修改
    //常量不能直接赋值 变量可以
    char ch3[20] = "china";
    ch3[0] = 'm';
    printf("%#x\n", ch3);
    printf("%s\n", ch3);
    //指针表示字符串   
    char *ch4= "china";
    //china是常量  常量区不能访问，ch4指向常量区首地址
    //ch4[0] = 's';
    printf("%#x\n", ch4);
    printf("%s\n", ch4);
    //copy 复制到ch 的地址上
    char *ch = (char *)malloc(100 * sizeof(char));
    strcpy(ch, "china");
    ch[0] = 'm';
    printf("%#x\n", ch);
    printf("%s\n", ch);
    free(ch);
    ch = NULL;
    system("pause");

    return 0;
}

总：区分常量区和申请内存，常量区不能被修改，不然会报错，字符串末地址一般 \0 代表是结束。

========

int main(){
    //char de[25];
    char *de = (char *)malloc(100 * sizeof(char));
    char *blank = "   ", *c = "c++", *ok = "ririrri"; 
    strcpy(de, ok);
    strcat(de, blank);
    strcat(de, c);
    printf("%s\n", de);
    free(de);
    system("pause");
    return 0;
}

总：关于字符串的操作函数，有50多中自行学习，自行找资料；