C语言补习课——内存篇

来源：黑马程序员

C语言常用占位符

1.%d 或 %i：用于输出有符号整数（int）。

2.%u：用于输出无符号整数（unsigned int）。

3.%f：用于输出浮点数（float或double）。默认情况下，输出六位小数。

4.%lf：专门用于输出double类型的浮点数（尽管%f也可以，但%lf更明确）。

5.%c：用于输出单个字符（char）。

6.%s：用于输出字符串（char数组）。

7.%x 或 %X：用于输出无符号整数（unsigned int）的十六进制形式，%x使用小写字母，%X使用大写字母。

8.%o：用于输出无符号整数（unsigned int）的八进制形式。

9.%%：输出一个%字符。

10.%p：用于输出指针的值，以十六进制形式表示。

11.%zu：专门用于输出size_t类型的无符号整数值。

第146讲 共同体

引入共同体的原因是一种数据可能有多种类型。

语法：

union [共同体名称]{

}；

示例：

union MoneyType {
	int moneyi;
	double moneyd;
	char  moneystr[100];
};

注意每个类型的共同体成员不能重名，并且每次只能赋一个值！

C语言给字符串型变量进行赋值建议用strcpy函数，函数原型如下：

char *strcpy(char *dest, const char *src);

变量介绍：

dest 是指向用于存储复制内容的目标数组（字符串）的指针。

src 是指向要复制的源字符串的指针。

函数返回目标字符串的指针。

我这里用的visual studio推荐用strcpy_s，中间需要加一个参数代表原字符串型变量的大小。

参考代码：

#include <stdio.h>
#include <string.h>

typedef union{
	int moneyi;
	double moneyd;
	char  moneystr[100];
} MoneyType;
	


int main()
{
	MoneyType money;
	//money.moneyi = 100;
	//money.moneyd = 99.5;
	strcpy_s(money.moneystr,sizeof(money.moneystr),"100万");

	//printf("%d\n",money.moneyi);
	//printf("%lf\n", money.moneyd);
	printf("%s\n", money.moneystr);


	return 0;
}

第147讲 共用体的特点

共用体的特点：

● 共用体,也叫联合体,共同体

● 所有的变量都使用同一个内存空间

● 所占的内存大小=最大成员的长度(也受内存对齐影响，总大小也一定是最大成员的整数倍)

● 每次只能给一个变量进行赋值,因为第二次赋值时会覆盖原有的数据

在上一讲的基础上运行下面的代码

	printf("%p\n",&(money.moneyi));
	printf("%p\n",&(money.moneyd));
	printf("%p\n",&(money.moneystr));

运行结果：

得证所有的变量都使用同一个内存空间。

那么上一讲的money到底占用多少内存呢？

	printf("%zu",sizeof(money));

输出结果：

原因是char  moneystr[100]并不能视为最大长度的成员，它是100个char类型的变量组成的数组。最大长度成员是double，也就是说这个联合体的大小不仅得大于100，而且得是8的倍数。100不起字节，加4刚好是8的倍数。

第148讲 结构体和共同体的区别

使用场景：

              结构体：一个事物包含多种属性

               联合体：一个属性有多种类型

存储方式:

                结构体:各存各的

                共用体:存一起,多次存会覆盖

内存占用:

               结构体:各个变量的总和(受内存对齐影响)

              共用体:最大类型(受内存对齐影响)

第149讲 动态内存分配常用函数

总览

注意：这四个函数需要#include <stdlib.h>才能使用。

malloc

malloc函数适合用来申请连续的空间，函数原型如下所示：

void* malloc(size_t size);

通过 malloc，程序可以在堆区（heap）动态地请求分配指定大小的内存块，并在分配成功后返回一个指向该内存块的指针。如果分配失败（例如，由于内存不足），malloc 会返回 NULL 指针。

参数size 指定了要分配的内存大小，单位是字节（byte）。

由于数组是占用一段连续内存空间的数据结构，所以我们可以直接用数组来操作这一段内存空间。

举例：

int *p=malloc(10 * sizeof(int));

指针p指向的连续内存可以存储10个int类型数据，这时候可以直接给p[0]到p[9]赋值。

p[0]=100;

总体示例：

#include <stdio.h>
#include <stdlib.h>

int main()
{
   //开辟一片能存储100个int类型整数的连续内存空间
    int *p=malloc(10 * sizeof(int));
    printf("%p\n",p);

    for (int i = 0; i < 10; i++)
    {
        //赋值方法1 指针步进
        //*(p + 1) = (i + 1) * 10;

        //赋值方法2 遍历数组
        p[i]= (i + 1) * 10;
    }

    for (int i = 0; i < 10; i++)
    {
        printf("%d ",p[i]);
    }



    return 0;
}

calloc

函数原型：

void *calloc(size_t num, size_t size);

参数：①num 要分配的元素数量

           ②size  每个元素的大小 

返回值：成功时，返回一个指向分配的内存的指针。这块内存的大小至少是 num * size 字节，并且所有位都被初始化为零。如果分配失败（例如，因为内存不足），则返回 NULL 指针。

重点掌握malloc函数，效率更高；calloc的初始化就是默认赋值为0作用不大。

realloc 

函数原型：

void* realloc( void*  _Block， size_t _Size);

参数：①通用指针_Block 指向想要修改的内存块的指针

           ②size 想要扩充的字节大小

realloc可以扩容内存并且保存原来的数据，但是新开辟的空间里面存储的是乱码

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int* p = calloc(10,sizeof(int));
	for (int j = 0; j < 10; j++) {
		p[j] = j * 10+1;
		printf("%d ",p[j]);
	}

	printf("\n");

	int *pp=realloc(p,20*sizeof(int));
	for (int i = 0; i < 20; i++) {
		printf("%d ", p[i]);
	}


	return 0;
}

运行结果：

另外最好不要用这个函数，影响代码安全性。上次windows蓝屏不就是因为微软新来了一个小孩，他的野指针在天上飞么？（bushi

free

函数原型：

void free(void* _Block);

不用了的内存空间最好随手释放,填入你想要释放的内存块的地址。

第150讲 malloc函数的细节点

动态内存分配的小细节：

1,malloc创建空间的单位是字节

因此malloc(100)之后能存储25个int类型数据，50个short型数据。

2,malloc返回的是void类型的指针,没有步长的概念,也无法获取空间中的数据,需要强转

malloc返回类型是void*,void *p无法进行*(p+1)这样的操作，正确做法：

	int *p=(int *)malloc(100);
	*(p + 1) = 10;

当然也可以强转成其他返回类型

3,malloc返回的仅仅是首地址,没有总大小,最好定义一个变量记录总大小

上文的int*规定了指针步长，p指针指向了内存的首地址，所以开辟一个100字节的内存可以存储25个int类型。

#include <stdio.h>
#include <stdlib.h>

#define length 25

int main()
{
	int* p = (int*)malloc(length * sizeof(int));
   
	for (int i = 0; i < length; i++) {
		p[i] = i * 4 + 7;
	}
	
	printPoint(p,length);
	return 0;
}

int printPoint(int* point, int len)
{
	for (int i = 0; i < len; i++) {
		printf("%d ",point[i]);
	}
	printf("\n");
}

4,malloc申请的空间不会自动消失,如果不能正确释放,会导致内存泄露

5,malloc申请的空间过多,会产生虚拟内存
当申请的空间过多,因为每一个内存空间不会在刚申请的时候就立马使用，所以c语言并不会立马就在内存中去开辟空间,而是什么时候存储数据了,才会真正的分配空间
目的:为了提高内存的使用效率

6,malloc申请的空间没有初始化值,需要先赋值才能使用

7,free释放完空间之后,空间中数据叫做脏数据,可能被清空,可能被修改为其他值

8,calloc就是在malloc的基础上多一个初始化的动作

9,realloc修改之后的空间,地址值有可能发生变化,也有可能不会改变,但是原本的数据不会丢失

10,realloc修改之后,无需释放原来的空间,函数底层会进行处理

第152讲 C语言的内存结构

第153讲 变量数组在内存中的运行情况

假设存在这样一段代码：

#include <stdio.h>

int main()
{
	int a = 10;
	int b = 20;
	int arr[] = {1,2,3};

	return 0;
}

点击运行键之后，首先所有代码都会被放在代码区进行临时存储，编译器会逐行检查代码，然后将main函数放入栈区进行自动调用。

main函数在栈区自动开辟了两个小空间用于存储a和b，需要使用时就寻址使用这两个变量。

arr的本意还是代表三个int类型变量组成的数组，用sizeof测量大小输出的是12（sizeof（int）*3）

但是当arr参与运算的时候，arr会退化成为指向数组首个元素地址的指针

main函数执行完毕之后会出栈，函数体内部的所有变量都会被销毁

第154讲 全局变量与静态变量在内存中的运行情况

先上代码

#include <stdio.h>

int g_a = 10;

int* method(void)
{
	static int b = 20;
	return &b;
}

int main()
{
	int *p = method();    //对“&b”解引用，得到b的实际数值
	printf("%d\n",*p);

	return 0;
}

代码整体还是先在代码区临时存储，编译器遍历代码发现g_a这个全局变量，于是将它放置在初始化静态区；总结函数体内部的局部变量存储在栈区，函数体外部未赋值的全局变量存储在初始化静态区域，已赋值的全局变量存储在未初始化静态区域。但如果在函数体内部使用了static修饰局部变量，那么它也会被存储在初始化静态区，类似于上面method函数中的变量b。

知识补充：字符数组与字符串

字符数组是数组的一种特殊形式，其中每个元素都是一个字符类型（char）。因为C语言中不存在不存在名为 string 的内置类型，所以我们声明字符串变量都通过字符数组来实现，并且在数组的末尾加上'\0'空字符作为字符串结束标志。

一提到定义一个字符串我们的第一印象都是：

char* str0 = "Hello";

char* str 声明了一个指向字符常量的指针 str。虽然这个声明本身并不直接定义一个字符串，但它经常被用来操作字符串，这就是因为C语言中的字符串实际上是通过字符数组实现的，并以空字符（'\0'）作为结束标志（二次重复表重要）。这里的 char* str 可以指向一个字符数组（即字符串）的首元素，从而实现对字符串的引用和操作。

对字符数组进行修改与访问：

	char* str0 = "Hello";                      //注意此时str0指向字符串常量，无法作为左值
	char str1[] ="Hello";                      //自动包含空字符'\0'作为字符串的结束标志
	char str2[] = {'H','e','l','l','o','\0'};  //显式地包含空字符，与上面两个例子等价


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

	for (int i = 0; i < 5; i++)
	{
		printf("%c ",str1[i]);
		
	}

	printf("\n");

	for (int i = 0; i < 5; i++)
	{
		
		str2[i] = 'a';
		printf("%c ", str2[i]);
	}

注意在C语言中，当你使用 char *str = "Hello"; 这样的语句时，str 实际上是指向一个字符串常量 "Hello" 的指针。字符串常量通常存储在只读内存区域，因此你不能通过 str 指针来修改它所指向的字符串的内容。

第155讲 字符串在内存中的内存情况

示意框图：

代码：

	char* str1 = "abc";  //str1被存放在了常量区里面无法直接作为可修改的左值
	str1 = "aaa";        //但我们可以创建一个新的字符串“aaa”
	char str[] = "abc";  //str被存放在了栈区可以修改
	printf("str:%s\n",str);

	for (int i = 0; i < 3; i++)
	{
		str[i] = 'a';
	}
	printf("str:%s\n", str);

第156讲 malloc函数在内存中的运行状况

malloc使用关键点

解决方法是添加#include <stdlib.h>

堆与malloc

代码示例：

#include <stdio.h>
#include <stdlib.h>

int main()
{
	int* p = (int *)malloc(100);
	*p= 100; 
	printf("%d\n",*p);


	return 0;
}

代码讲解：定义了指针*p指向malloc开辟的堆区空间的首地址（大小为100字节）。

注意malloc开辟的内存空间位于堆区，如果数组占用内存较大，推荐在堆区开辟内存

函数（当然包括main函数）和它内部的局部变量会在执行完毕之后被自动清除，但堆中开辟的空间只要不被free就不会释放。

特点汇总

`