C语言 | 变量、函数及内存分区

目录

全局变量（存储在数据区）

静态变量（存储在数据区）

全局变量、局部变量、静态全局变量、静态局部变量对比

二、函数

静态函数

三、内存分区

四、内存相关函数

malloc()  [#include ]

free()  [#include ]

memset()  [#include ]

memcpy()  [#include ]

memmove()  [#include ]

memcmp()  [#include ]

五、申请二级指针对应的堆空间

---

• 全局变量（存储在数据区）

1. 在函数外定义，可被本文件及其它文件中的函数所共用，若其它文件中的函数调用此变量，须用 extern 声明。（extern：声明变量为外部变量）
2. 全局变量的生命周期和程序运行周期一样。
3. 不同文件的全局变量不可重名。

• 静态变量（存储在数据区）

1. 静态局部变量只会初始化一次，可以多次赋值。
2. 静态全局变量可以在本文件中使用，不可以在其他文件中使用。

• 全局变量、局部变量、静态全局变量、静态局部变量对比

变量类型	作用域	生命周期	存储位置
全局变量	项目中所有文件	从程序创建到程序销毁	数据区
局部变量	函数内部	从局部变量创建到函数结束	栈区
静态全局变量	变量所在的文件	从程序创建到程序销毁	数据区
静态局部变量	函数内部	从程序创建到程序销毁	数据区

二、函数

• 静态函数

在 C 语言中，函数默认都是全局的，使用关键字 static 可以将函数声明为静态，函数定义为 static 就意味着这个函数只能在定义这个函数的文件中使用，在其他文件中不能调用，即使在其他文件中声明这个函数都没用。对于不同文件中的 staitc 函数名字可以相同。而全局函数的名称是作用域中唯一的，不可重名。

静态函数可以和全局函数重名，就近一致原则。

函数类型	作用域	生命周期	存储位置
全局函数	项目中所有文件	从程序创建到程序销毁	代码区
静态函数	定义所在文件中	从程序创建到程序销毁	代码区

三、内存分区

1. 代码区（共享、只读）：存放 CPU 执行的机器指令。通常代码区是可共享的（即另外的执行程序可以调用它），使其可共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指令。另外，代码区还规划了局部变量的相关信息。
2. 数据区：
   a.常量区；
   b.全局初始化数据区 / 静态数据区 ( data 段 )：该区包含了在程序中明确被初始化的全局变量、已经初始化的静态变量 ( 包 括全局静态变量和局部静态变量 ) 和常量数据 ( 如字符串常量 ) ；
   c.未初始化数据区 ( 又叫 bss 区 )：存入的是全局未初始化变量和未初始化静态变量，未初始化数据区的数据在程序开始执行之前被内核初始化为 0 或者空 ( NULL )。
           程序在加载到内存前，代码区和全局区 ( data 和 bss ) 的大小就是固定的，程序运行期间不能改变。然后，运行可执行程序，系统把程序加载到内存，除了根据可执行程序的信息分出代码区（ text ）、数据区（ data ）和未初始化数据区（bss）之外，还额外增加了栈区、堆区。 
3. 堆区（Heap）：堆是一个大容器，它的容量要远远大于栈，但没有找那样先进后出的顺序。用于动态内存分配。堆在内存中位于 BSS 区和栈区之间。一般由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。（由低地址向高地址存放）
4. 栈区（Stack）：系统为每一个程序分配一个临时的空间，存放函数的参数值、返回值、局部变量、指针、数组等。在程序运行过程中实时加载和释放，栈区大小为1M，windows端可以扩展到10M，Linux中可以扩展到16M。（先高地址后低地址存放）

四、内存相关函数

• malloc()  [#include <stdlib.h>]

void* malloc (size_t size) ;

功能：在内存的动态存储区（堆区）中分配一块长度为size字节的连续区域，用来存放类型说明符指定的类型。分配的内存空间内容不确定，一般使用memset 初始化。

参数：需要分配内存大小 ( 单位 : 字节 )。

返回值：成功：分配空间的起始地址；失败 : NULL。

• free()  [#include <stdlib.h>]

void free (void* ptr);

功能：释放ptr所指向的一块内存空间 ，ptr 是一个任意类型的指针变量，指向被释放区域的首地址。对同一内存空间多
次释放会出错。

参数：需要释放空的首地址，被释放区应是由 malloc 函数所分配的区域。

★ 堆内存不可以多次释放。 

void OperatorMalloc()
{
    int* p =(int* )malloc(sizeof(int) * 10);
    printf("%p\n", p);
    *p = 10;//使用堆空间
    printf("%d\n", *p);
    free(p);//释放堆空间
    p = NULL;//一定要赋值NULL,否则为野指针
}

• memset()  [#include <string.h>]

void* memset ( void* s,int c,size _ t n) ;

功能：将s的内存区域的前n个字节以参数c填入。

参数：s：需要操作内存s的首地址；c：填充的字符，c虽然参数为int，但必须是 unsignedchar，范围为0~ 255。n：指定需要设置的大小。

返回值：s 的首地址。

void OperatorMemset()
{
    int* p = (int*)malloc(sizeof(int) * 10);
    printf("%p\n", p);
    memset(p, 0, sizeof(int) * 10);
    printf("%d\n", *p);//0
    memset(p, 1, sizeof(int) * 10);
    printf("%d\n", *p);//16843009
    free(p);//释放堆空间
    p = NULL;//一定要赋值NULL,否则为野指针

    char ch[10];
    memset(ch, 'A', sizeof(char) * 10);
    printf("%c\n", ch[9]);//A
}

memset(p, 1, sizeof(int) * 10);后，*p的值是16843009，是因为：memset是一个一个字节进行初始化的，就是对p指向的内存的40个字节进行赋值，每个都用ASCII为1的字符去填充，转为二进制后，1占一个字节，就是00000001。一个int元素是4字节，即00000001000000010000000100000001，就等于十进制的16843009。

• memcpy()  [#include <string.h>]

void* memcpy(void* dest, const void* src, size_t n);

功能：拷贝src所指的内存内容的前n个字节到dest所指的内存地址上。

参数：dest：目标内存首地址；src：源内存首地址；n：需要拷贝的字节数。

返回值：dest的首地址。

★ dest与src所指的内存空间不可重叠，否则可能会导致程序报错。 

void operatorMemcpy()
{
    char ch[] = "hello\0 world";
    char ch1[100];
    //strcpy(ch1, ch);//字符串拷贝，遇到\0停止
    memcpy(ch1, ch, 10);//内存拷贝，遇到\0不停止
    printf("%s\n", ch1);//hello
    for (size_t i = 0; i < 10; i++)
    {
        printf("%c", ch1[i]);//hello  wor
    }

    putchar('\n');
    //内存拷贝，拷贝的内容和字节有关
    int arr[] = { 1,2,3,4,5,6,7,8,9,10};
    //下面这句代码，dest与src所指的内存空间有折叠，有可能会导致程序报错。
    memcpy(&arr[5], &arr[3], 20);//从下标为3开始，复制20个字节，即5个整型放到下标为5的位置
    for (size_t i = 0; i < 10; i++)
    {
        printf("%d", arr[i]);//1234545678
    }
    
}

• memmove()  [#include <string.h>]

void* memmove(void* dest, const void* src, size_t n);

memmove()功能用法和 memcpy()一样，区别在于： dest 和 src 所指的内存空间重叠时， memmove()仍然能处理，不过执行效率比 memcpy()低些。

void operatorMemmove()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
    memmove(&arr[5], &arr[3], 20);//从下标为3开始，复制20个字节，即5个整型放到下标为5的位置
    for (size_t i = 0; i < 10; i++)
    {
        printf("%d", arr[i]);//1234545678
    }
}

• memcmp()  [#include <string.h>]

void* memcpy(const void* s1, const void* s2, size_t n);

功能：比较s1和s2所指向内存区域的前n个字节。

参数：s1：内存首地址s1；s2：内存首地址s2；n：需比较的前n个字节。

返回值：相等：0；大于：1；小于：-1。

void OperatorMemcmp()
{
    char ch1[] = "hello\0 world";//13个字符
    char ch2[] = "hello";//6个字符
    int ret = memcmp(ch1, ch2, 6);
    printf("%d", ret);//0
    ret = memcmp(ch1, ch2, 7);
    printf("%d", ret);//-1
}

五、申请二级指针对应的堆空间

void OperatorP2P()
{
    //申请二级指针对应的堆空间 int arr[5][3]
    int** p = (int**)malloc(sizeof(int*) * 5);
    for (size_t i = 0; i < 5; i++)
    {
        p[i] = (int*)malloc(sizeof(int) * 3);
    }

    //释放堆空间
    for (size_t i = 0; i < 5; i++)
    {
        free(p[i]);
    }
    free(p);
}