C语言学习笔记九、全局变量和局部变量、静态变量、堆空间

九、全局变量和局部变量、静态变量、堆空间

1. 全局变量和局部变量

全局变量：定义在函数的外面的变量，在主函数前面或头文件；在所有的函数里面都可以使用
局部变量：定义在函数的内部，只能在某个函数里面使用

注意：
    1》全局变量未初始化，他的值默认为0
    2》局部变量会被花括号{}限制作用域
        在循环语句里面定义变量，它只会定义一个，
        如果有初始化赋值，每次都会重新赋值
    3》当全局变量和局部变量名相同时，在函数内部默认使用的是局部变量
    
例子：
#include <stdio.h>
#include <string.h>

int num;

//num =2000 ; //会有警告，最好不要这么做，如果要最好直接初始化赋值
//printf(" &num:%p\n", &num); 函数外部不能调用函数
    
int main(int argc, const char**argv)
{    
    printf("main0 &num:%p\n", &num); 
    printf("main1 num:%d\n", num); //0

    int num = 200;
    printf("main  &num:%p\n", &num); 
    printf("main2 num:%d\n", num); //200
    
    func();
    
    return 0;
}

int func()
{
    printf("func num:%d\n", num);    //0
    printf("func &num:%p\n", &num);
    return 0;
}

2. 静态变量---》使用static修饰的变量

1、特点：只能在当前.c文件使用
            静态变量未初始化也是默认为0
2、分类：
        1>全局静态变量：在当前.c文件里面所有函数都可以使用
        2>局部静态变量：
                    定义在函数的内部，只能在某个函数里面使用，
                    但是在函数调用结束后，它的内存不会被释放，
                    它可以保留原本值
                    
#include <stdio.h>
#include <strings.h>
#include <string.h>

static int a;

int main(int argc, const char*argv[])
{
    
    printf("a:%d\n", a);
    
    func();//c==0
    func();//c==1
    func();//c==2
    
    func1();//d==100     e==100
    func1();//d==101     e==100
    func1();//d==102     e==100
    
    return 0;
}
int func()
{
    static int c;
    printf("c:%d\n", c);
    c++;
    a = 100;
    printf("a:%d\n", a);
    return 0;
}
int func1()
{
    static int d=100;  //静态局部变量，函数不管被调用几次，只会被定义一次，而且只会被初始化一次
    printf("d:%d\n", d);
    d++;
    
    int e=100;        //普通局部变量，函数不管被调用几次，每次都会被定义一次，而且每次都会初始化
    printf("e:%d\n", e);
    e++;
    
    return 0;
}

3. 堆空间的申请和释放

堆空间的申请：malloc, calloc, realloc
堆空间的释放：free

函数接口：
#include <stdlib.h>

void *malloc(size_t size);
void free(void *ptr);
void *calloc(size_t nmemb, size_t size);
void *realloc(void *ptr, size_t size);

函数及形参的说明：
1、malloc-->申请堆空间size个字节内存，内存没有被清空的;
如果申请成功，他会返回堆空间的起始地址，失败返回NULL

形参作用：
    size --》申请的内存字节数

2、free-->释放内存

    3、calloc-->申请堆空间内存，如果申请成功，他会返回堆空间的起始地址，失败返回NULL
       和malloc的区别，calloc申请的内存已经被清空，malloc申请内存里面的数据是随机值
    
    void *calloc(size_t nmemb, size_t size);
    形参作用：
    nmemb --》申请多少块内存
    size --》申请的每块内存的字节数
    
4、realloc-->可以申请堆空间内存，也可以用来扩展堆空间内存
    
    void *realloc(void *ptr, size_t size);
    形参作用：
        ptr--》如果写NULL，会申请一块新的堆空间内存；
                如果写已经申请的堆空间内存的首地址，它会扩展堆空间的内存
                如果要扩展的内存已经被其他变量使用了，它会重新申请一块足够大的内存，
                然后内存的起始地址就会发生改变
                
        size --》申请的内存的字节数
=============================
例子：
#include <stdio.h>
#include <strings.h>
#include <string.h>

int main(int argc, const char*argv[])
{
    //int a =100;//系统申请了4个字节内存，并把这块内存命名为a，把100转为二进制存储到这块内存里面
    
    //使用堆空间实现类型int a=100的效果
    //申请了4个字节内存
    int *p = (int *)malloc(4);
    bzero(p, 4);//清空内存
    
    
    if(p == NULL)
    {
        printf("calloc failed!\n");
        return -1;
    }
    
    //把100转为二进制存储到这块堆空间这块内存
    *p = 100;
    
    printf("%d\n", *p);
    
    //释放内存
    if(p != NULL)
    {
        free(p);
        p=NULL;
    }
    
    return 0;
}