小小君的C语言第十课

#import <Foundation/Foundation.h>

// 利用关键字 static修饰的变量 叫做静态变量并且储存在静态区

// 特点1：如果你不给初值默认是 0

// 特点2：只初始化一次

static int number1 =10;     //全局静态变量

// 全局变量

int number2 = 5;

//void function(){

//    // 局部静态变量

//    // 局部静态变量的作用域到大括号结束为止

//

//    static int num = 10;

//    num++;

//    printf("num = %d\n", num);

//}

void function1(){

    int a =5;

    int b =6;

    printf("%d  %d\n", a, b);

}

void function2(){

    int value =100;

    printf("%d \n", value);

}

void function3(){

    int temp;

    printf("%d \n", temp);

}

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

    

  

    // 内存划分为5个区域：栈区、堆区、静态区、常量区、代码区

    // 内存地址由高到低

    // 学习目标：按顺序记忆

    

    

    

#pragma mark -- 代码区

    

    // 电脑的存储都是以二进制数据进行存储的

    // 代码会被系统转化成二进制数据存储到代码区

    

    

    

#pragma mark -- 常量区

    

    // 常量区存储的常量特点

    // 常量是运行期间 不能改变的量

//    char *str = "dajun";

//    // 把 j更改成'z'

//   // *(str + 2) = 'z';       // 企图修改常量。系统崩溃

//   

//    str = "haha";   // 指针的赋值就是指针的重指向

//    printf("%s\n",str);

//    

//    

//    char str1[] = "dajun";

//    // 数组名字地址 数组首元素的地址

//    // 数组首元素的常量地址

//    // 把“  j改成' y'

//    // 是把常量区的常量字符串拷贝到 栈区

//    str1[2] = 'w';

//    printf("%s\n",str1);

    

    

  

    

#pragma mark -- 静态区

    

    // 静态区： 存储两种变量

    // 1.静态变量

    // 2.全局变量

    // 静态区变量保存周期：直到程序运行结束，静态变量 才会被释放

//    function();

//    function();

//    function();

    

    

    

    

    

#pragma mark -- 栈区

    

    int n1 =5;

    int n2 =10;

    int n3 =15;

    

    function1();

    

    printf("%p\n", &n1);

    printf("%p\n", &n2);

    printf("%p\n", &n3);

    

    

    // 栈区有多大？

    // 大概 7M - 8M

   // char str[8187 * 1024] = {0};

    

    

    // 出栈入栈的规则

    // 先入栈的后出栈先入栈的 在栈底

    // 入栈压栈

    // 出栈顺序： 从栈顶开始出栈

    // 之所以栈区容量不是特大又不会出现崩溃的现象是因为栈区频繁的进行出栈和入栈 只要一次性不把栈空间堆满，不会轻易的崩溃。

    

    //  定义变量的时候切记：给初值，避免出现莫名其妙的问题

    function2();

    function3();

    

    

    

    

#pragma mark -- 堆区

    

    // 堆区是程序员开辟空间是程序员释放空间

    // 手动开辟空间手动释放空间

    // 堆区的空间大概就是内存的空间

    

    

    // 开辟空间函数

   // void *malloc(<#size_t#>)

    // void * 代表无类型指针可以转化成任何类型的指针

    // size 开辟空间的大小开辟多少字节空间

    

    // 给整型指针p指向的位置开辟了4个字节的堆内存空间

    int *p =malloc(4);

    *p = 10;

    printf("%d\n", *p);

    

    char *str =malloc(8);

    strcpy(str,"dajun");     //正确

    strcpy(str,"dajundajunda");      //错误  开辟了多少空间不要超过开辟的空间

    

    int *p1 =malloc(4);

    *p1 = 5;

    // 开辟多少空间最好你就用多少

    short *p2 =malloc(4);

    *p2 = 10;

    *(p2 + 1) =15;

    

    // 释放空间函数

    // free(*p1);

    // 1、标记删除不会抹去该空间存储的数据 只会把这块空间标记为可用

    // 2、把指针置为空

    

    // 开辟空间

    int *p3 =malloc(4);

    

    // 使用空间

    *p3 = 10;

    printf("%d\n", *p);

    

    // 释放空间

    free(p3);

    p = NULL;

    

    int *p4 =malloc(sizeof(int ) *5);

    for (int i =0;  i < 5; i++) {

        *p4 = i + 1;

        p4++;

    }

    // 指针地址发生变化释放本不属于开辟的区域 这时候就会崩溃

    

    // 修改：把指针移回去

    for (int i =0;  i < 5; i++) {

        p4--;

    }

    

    free(p4);

    p4 = NULL;

    

    // 有一字符串,其中包含数字,提取其中的数字.要求动态分配内存保存

    // 提⽰:先计算出有⼏个数字,然后根据数字的个数来开辟空间.

    

    char str1[] ="da52jun094ai23z2p5mhd";

    // 计算出有多少数字

    int count =0;

    

    for (int i =0; i < strlen(str1); i++) {

        if (str1[i] >='0' && str1[i] <= '9') {

            // 进到分支肯定是数字

       //     str1[count] = str1[i];

            count++;

        }

        

    }

    char *pchar =malloc(count + 1);

    int index =0;

    for (int i =0; i < strlen(str1); i++) {

        if (str1[i] >='0' && str1[i] <= '9') {

            // 进到分支肯定是数字

            pchar[index] = str1[i];

            index++;

        }

        

    }

    

    *(pchar + index) = '\0';

    printf("%s\n", pchar);

    

    free(pchar);

    pchar = NULL;

    

    

    // 输入3个学员的姓名,动态分配内存保存学员姓名,并在最后输出

    

    char *names[3] = {0};

    char st[] = {0};

    for (int i =0; i < 3; i++) {

        printf("输入姓名：\n");

        

        scanf("%s",st);

        

        // 开辟空间

        names[i] = malloc((int)strlen(st) +1);

        // 保存字符串

        strcpy(names[i], st);

    }

    

    

    for (int i =0; i < 3; i++) {

        printf("%s  ", names[i]);

        free(names[i]);

        names[i] = NULL;

    }

    

    

    

    // 其他分配堆内存函数

    // 在堆内存中开辟 n * size 个字节空间并且把开辟的内存空间清零

    // 因为有一个清零的过程，所以效率偏低

    // calloc(int n, size);

    

    int *a =calloc(3,sizeof(int));

    

    

    // 重新分配函数

    // realloc(原来分配的地址,新的空间大小)

    // 情况1、如果原来分配的地址可以扩充空间那么就在原地址扩充

    // 情况2、如果原来分配的地址不能扩充那么系统会重新分配一个空间 并且把原来地址储存的数据拷贝到新空间里然后系统自动释放原地址的空间

    

    int *p_old =malloc(10);

    printf("%p\n", p_old);

    int *p_new =realloc(p_old, 15);

    printf("%p\n", p_new);

    // free(0_old); 过度释放

    free(p_new);

    p_new = NULL;

    

    

    // 内存操作函数

    // 把开辟的空间多少字节 重置成 c

    // memset(开辟空间的指针,  int c,字节数)

    // 用途：把开辟好的空间清零

    

    int *pp =malloc(sizeof(int) *4);

    for (int i =0; i < 4; i++) {

        pp[i] = i + 5;

    }

    // 清零

    memset(pp,0, 16);

    for (int i =0; i < 4; i++) {

        printf("%d  ", pp[i]);

    }

    

    

    

    // 内存拷贝函数

    // 从来源拷贝 到目的地 多个字节

    // *memcpy(目的地,来源,字节数)；

    

    // 内存比较函数

    // 两个地址按字节 进行比较返回第一个不同的差值

    // memcmp(指针1,指针2,字节数)

    

    

  

    

    return0;

}