复习_回顾所学的_C/C++_new_内存使用(详解)

其他 2020-04-18 15:39:02 阅读次数: 0

1. C++程序的内存分区

在这里插入图片描述
在这里插入图片描述
1、栈区（stack）：由编译器自动分配释放，存放函数的参数值，局部变量值等。
2、堆区（heap）：一般由程序员分配释放，随叫随到，挥之即走。
3、全局/静态区（static）：全局变量和静态变量的存储是放在一起的，在程序编译时分配。
4、文字常量区：存放常量字符串。
5、程序代码区：存放函数体（包括类的成员函数、全局函数）的二进制代码

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

int lao_ye_zi = 58;

//1.栈的内存
void say_hello(const char *msg){ //函数的参数和局部变量存放在栈区
	//int x, y, z;

	if(msg){
		printf("hello, %s", msg);
	}else{
		printf("hello, who are u?\n");
	}

	printf("老爷子今年: %d 岁\n", lao_ye_zi);
	
}

void gui_fang(int jiaren){
	static int girl = 17;
	if(girl == 17){
		girl = 18;
	}else{
		girl = 16;
	}

	printf("小姐今年 %d\n", girl);
}

int main(){
	int num = 0;
	int *salary = NULL;

	//4. 字符常量
	char *p = "童养媳";
	char *p1 = "童养媳";

	printf("p: 0x%p p1: 0x%p\n", p, p1);
	//system("pause");
	//exit(0);

	//3.全局变量/静态变量
	printf("老爷子今年: %d 岁\n", lao_ye_zi);
	gui_fang(0);
	gui_fang(0);
	//salary = new int(666);

	//2.堆, 动态内存分配
	salary = new int; //在堆区分配内存
	*salary = 100;
	printf("salary: %d\n", *salary);
	delete salary;
	//system("pause");
	//exit(0);
	//say_hello("骚年们!");
	printf("请输入需要雇佣的农民数量: \n");
	scanf_s(" %d", &num);
	if(num <= 0){
		printf("请重新输入: \n");
	}

	salary = new int[num];
	for(int i = 0; i < num; i++){
		*(salary+i) = i+1;
	}

	for(int i = 0; i < num; i++){
		printf("第%d个农民的薪资: %d\n", i+1, salary[i]);
	}

	printf("---over---\n");
	delete[] salary;

	//切记, delete 后的动态内存, 禁止访问
	/*for(int i = 0; i < num; i++){
		printf("第%d 个农民的薪资: %d\n", i+1, salary[i]);
	}*/

	system("pause");
	return 0;
}

运行结果:
在这里插入图片描述

2. 为什么要使用动态内存

1.按需分配，根据需要分配内存，不浪费

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

int main(){
	int farmer[10] = {20, 22, 25, 19, 18, 23,17, 28, 30, 35};
	int num = 0;
	int *salary = NULL;

	printf("请输入需要雇佣的农民数量: \n");
	scanf_s("%d", &num);

	if(num<=10){
		printf("请重新输入: \n");
		system("pause");
		exit(0);
	}

	//后面新增的都是18
	salary = new int[num];
	//第一种, 逐个赋值
	/*for(int i = 0; i < sizeof(farmer)/sizeof(int); i++){
		*(salary+i) = farmer[i];
	}*/
	//第二种, 内存拷贝
	memcpy(salary, farmer, sizeof(farmer));

	for(int i = sizeof(farmer)/sizeof(int); i<num; i++){
		//salary[i] = 18;
		*(salary+i) = 18;
	}

	for(int i = 0; i < num; i++){
		printf("第%d个农民工的薪资: %d\n", i+1, salary[i]);
	}

	delete[] salary;

	system("pause");
	return 0;
}

运行结果:
在这里插入图片描述
内存拷贝函数
void *memcpy(void *dest, const void *src, size_t n);
#include<string.h>

功能：从源 src 所指的内存地址的起始位置开始拷贝 n 个字节到目标 dest 所指的 内存地址的起始位置中

new 分配内存布局图

在这里插入图片描述

2.被调用函数之外需要使用被调用函数内部的指针对应的地址空间

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

//通过返回动态内存的指针
int *demo(int count){
	int *ap = NULL;

	//new delete C++的动态内存分配操作符, C语言是 malloc
	ap = (int *)malloc(sizeof(int) * count);//参数: 所需内存的字节数
	//ap = new int[count];

	for(int i = 0; i < count; i++){
		ap[i] = 100+i;
	}

	for(int i = 0; i < count; i++){
		printf("*(ap+%d) = %d\n", i, *(ap+i));
	}

	return ap;
}

//通过二级指针来保存
void demo1(int count, int **pointer_p){
	int * ap = NULL;

	*pointer_p = (int*)malloc(sizeof(int) *count);

	ap = *pointer_p;
	for(int i = 0; i < count; i++){
		ap[i] = 100+i;
	}

	for(int i = 0; i < count; i++){
		printf("*(ap+%d) = %d\n", i, *(ap+i));
	}

}

int main(){
	//两种方式获取被调用函数内部的内存
	int * pointer = NULL;
	int count = 10;

	//第一种, 通过返回动态内存的指针
	//pointer = demo(count);

	//第二种, 通过二级指针来保存
	demo1(count, &pointer);

	for(int i = 0; i< 10; i++){
		printf("*(pointer+%d) = %d\n", i, *(pointer+i));
	}

	//用完了, 要记得释放
	free(pointer); //c语言中的释放内存函数, 相当于delete

	system("pause");
	return 0;
}

运行结果:
在这里插入图片描述
C 内存分配：
void *malloc(size_t size);
void free(void *);
malloc 在内存的动态存储区中分配一块长度为 size 字节的连续区域返回该区域 的首地址.

3.突破栈区的限制，可以给程序分配更多的内存

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

//栈区的空间大小是有限制的，windows 上一般是 1M - 2M 
void demo(){ 
	//int a1[102400*2]; //100k*2*4 = 800K 
	//int a1[102400*3]; //100k*3*4 = 1200K = 1.2M 
	int * a1; 
	//如果使用堆的话，64 位 windows 10 系统的限制是 2G 
	a1 = (int *)malloc((int)(1024*1000*1000));//分配 2G 
	a1[0]=0; 
	printf("This is a demo.\n"); 
}

int main(void){ 

	printf("--start--\n"); 
	demo(); 
	printf("--end--\n"); 

	system("pause"); 
	return 0; 
}

3. 动态内存的分配、使用、释放

new 和 delete 基本语法
1）在软件项目开发过程中，我们经常需要动态地分配和撤销内存空间，特 别是数据结构中结点的插入与删除。在 C 语言中是利用库函数 malloc 和 free 来 分配和撤销内存空间的。C++提供了较简便而功能较强的运算符 new 和 delete 来 取代 malloc 和 free 函数。
(注意： new 和 delete 是运算符，不是函数，因此执行效率高。)

2）虽然为了与 C 语言兼容，C++仍保留 malloc 和 free 函数，但建议用户不 用 malloc 和 free 函数，而用 new 和 delete 运算符

new 运算符的例子：
new int; //开辟一个存放整数的存储空间，返回一个指向该存储空间的地址(即指针)

new int(10); //开辟一个存放整数的空间，并指定该整数的初值为 10，返回一个指向该存 储空间的地址

new char[100]; //开辟一个存放字符数组(包括 100 个元素)的空间，返回首元素的地址

new int[5][4]; //开辟一个存放二维整型数组(大小为 5*4)的空间，返回首元素的地址

float *p=new float (3.14159); //开辟一个存放单精度数的空间，并指定该实数的 初值为//3.14159，将返回的该空间的地址赋给指针变量 p

3）new 和 delete 运算符使用的一般格式为：
使用方法：
指针变量 = new 类型(常量）;
指针变量 = new 类型[表达式]; //数组
指针变量 = new 类型[表达式][表达式] //二维数组

作用：从堆上分配一块“类型”指定大小的存储空间，返回首偶地址
其中：“常量”是初始化值，可缺省
创建数组对象时，不能为对象指定初始值

delete 运算符 释放已分配的内存空间
使用方式：
普通类型（非数组）使用: delete 指针变量；
数组 使用: delete[] 指针变量；
其中“指针变量” 必须时一个 new 返回的指针！

#include <stdlib.h>
#include <iostream>

using namespace std;

//分配基础类型
int main(){
	//第一种分配动态内存不执行初始化
	int *p1 = new int;
	*p1 = 100;

	//第二种分配动态内存同时执行初始化
	int *p2 = new int(100);

	//第三种 malloc 返回值是 void*
	int *p3 = (int*)malloc(sizeof(int));

	free(p1); //基础类型可以new free 可以混搭
	delete p3; //基础类型可以malloc delete 可以混搭
	delete p2; //free(p2); 同样的效果

	system("pause");
	return 0;
}

分配数组变量

//分配数组变量
int main(){
	int *p1 = (int *)malloc(sizeof(int)*10);
	//p[0] - p[9] *(p+9)
	int *p2 = new int[10];

	delete p1; //free(p1); 可以混搭
	//free(p2); //可以混搭
	delete[] p2;

	system("pause");
	return 0;
}

4. C++程序员的噩梦-内存泄漏

内存泄漏（Memory Leak） - 是指程序中己动态分配的堆内存由于某种原因程序未释放或 无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。

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

using namespace std;

void A_live(){
	int *p = new int[1024];
	//挥霍
	p[0] = 0;
	//申请的内存必须要"还"
}

void B_live(){
	int *p = new int[1024];
	//正常的开支
	p[0] = 0;
	//还
	delete[] p;
}

int main(){
	/*for(int i = 0 ; i < 100000; i++){
		A_live();
		Sleep(50);
	}*/

	for(int i = 0; i < 100000; i++){
		B_live();
		Sleep(50);
	}

	system("pause");
	return 0;
}

运行结果:
呃呃… 这里我就不运行了, 有兴趣的小伙伴运行下, 记得把上面的 for 循环打开, 来跑…

5. 函数返回值使用指针

可以返回函数内部：动态分配内存地址 局部静态变量地址 以及全局静态变量和外部变量 地址

#include <iostream>
#include <stdlib.h>

using namespace std;

int *add(int x, int y){
	int sum = x + y;

	return &sum;
}

//返回动态内存分配地址
int *add1(int x, int y){
	int *sum = NULL;
	sum = new int;
	*sum = x + y;

	return sum;
}

//返回局部静态变量的地址
int *add2(int x, int y){
	static int sum = 0;
	printf("sum: %d\n", sum);
	return &sum;
}

int main(){
	int a = 3, b = 5;
	int *sum = NULL;
	cout<<add(a, b)<<endl;
	//sum = addr(a, b); //不能使用外部函数局部变量的地址 bad

	//接收外部函数动态内存分配的地址: ok
	sum = add1(a, b);
	cout<<*sum<<endl;
	delete sum;

	//接收外部函数局部静态变量的地址
	sum = add2(a, b);
	cout<<*sum<<endl;
	*sum = 88888;
	add2(a, b);

	system("pause");
	return 0;
}

运行结果:
在这里插入图片描述

6.常见错误总结

  1. 申请的内存多次释放
  2. 内存泄漏
  3. 释放的内存不是申请时的地址
  4. 释放空指针
  5. 释放一个内存块，但继续引用其中的内容
  6. 越界访问
格罗马仕
发布了35 篇原创文章 · 获赞 33 · 访问量 291
私信 关注

猜你喜欢

转载自blog.csdn.net/m0_45867846/article/details/105593062
今日推荐
周排行
成为C++高手之宏与枚举
在CAD二次开发中使用进度条
Js插件ECharts，HighCharts学习网址整理
Celery提交任务出错(on windows.)
cephfs内核客户端性能追踪
thinkphp中PHPExcel用法
EntityFramework动态组合多排序字段
汇编语言（八）实验9 根据材料编程
安装ubuntu后必须做的事情（对我而言）
JS函数式编程
每日归档
更多
2024-10-22(0)
2024-10-21(0)
2024-10-20(0)
2024-10-19(0)
2024-10-18(0)
2024-10-17(0)
2024-10-16(0)
2024-10-15(0)
2024-10-14(0)
2024-10-13(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022