C++内存管理

最新推荐文章于 2022-08-07 17:45:52 发布
最新推荐文章于 2022-08-07 17:45:52 发布
阅读量60 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/parleychou/article/details/117284034
版权

C++ 内存管理

构建几个类和结构体：

class UpperClass
{
public:
	int a;
	int b;
	int c;
};

struct UpperStruct
{
public:
	int a;
	int b;
	int c;
};

class DownClass
{
public:
	int d;
	int e;
	int f;
};

class DownStruct
{
public:
	int d;
	int e;
	int f;
};

class DownTClass:public DownClass
{
public:
	int g;
	int h;
	int i;
};

测试几个类的大小和地址：

void Test01()
{
    UpperClass upperClass1;
    UpperStruct upperStruct1;

    upperClass1.a = 100;
    upperStruct1.a = 200;

    cout << "up1地址：" << (int)&upperClass1 << ";up1大小" << sizeof(upperClass1) << endl;
    cout << "up1-a地址：" << (int)&upperClass1.a << ";up1-a大小" << sizeof(upperClass1.a) << endl;
    cout << "up1-b地址：" << (int)&upperClass1.b << ";up1-b大小" << sizeof(upperClass1.b) << endl;
    cout << "us1地址：" << (int)&upperStruct1 << ";us1大小" << sizeof(upperStruct1) << endl;
    cout << "us1-a地址：" << (int)&upperStruct1.a << ";us1-a大小" << sizeof(upperStruct1.a) << endl;
    cout << "us1-b地址：" << (int)&upperStruct1.b << ";us1-b大小" << sizeof(upperStruct1.b)<<endl;

    cout << "**********************************************************************" << endl;
    UpperClass* upperClass2= new UpperClass();
    UpperStruct* upperStruct2= new UpperStruct();

    upperClass2->a = 100;
    upperStruct2->a = 200;
    
    cout << "up2地址：" << (int)upperClass2 << ";up2大小" << sizeof(*upperClass2) << endl;
    cout << "up2-a地址：" << (int)&upperClass2->a << ";up2-a大小" << sizeof(upperClass2->a) << endl;
    cout << "up2-b地址：" << (int)&upperClass2->b << ";up2-b大小" << sizeof(upperClass2->b) << endl;
    cout << "us2地址：" << (int)upperStruct2 << ";us2大小" << sizeof(*upperStruct2) << endl;
    cout << "us2-a地址：" << (int)&upperStruct2->a << ";us2-a大小" << sizeof(upperStruct2->a) << endl;
    cout << "us2-b地址：" << (int)&upperStruct2->b << ";us2-b大小" << sizeof(upperStruct2->b) << endl;
}

得到的结果：

up1地址：-1949304304;up1大小12
up1-a地址：-1949304304;up1-a大小4
up1-b地址：-1949304300;up1-b大小4
us1地址：-1949304288;us1大小12
us1-a地址：-1949304288;us1-a大小4
us1-b地址：-1949304284;us1-b大小4
**********************************************************************
up2地址：1855195248;up2大小12
up2-a地址：1855195248;up2-a大小4
up2-b地址：1855195252;up2-b大小4
us2地址：1855196048;us2大小12
us2-a地址：1855196048;us2-a大小4
us2-b地址：1855196052;us2-b大小4

结论：
通过new关键字定义的对象，存储位置都在堆区，不通过new关键字定义的对象，生成位置都在栈区；
通过new关键字定义的所有对象的成员都生成在堆区
类的地址为类的第一个对象所在的地址

假设：
类的地址，通过字节大小可以判断类的其他成员的地址，进而获取类中所有的对象

查看引用发生的变化

改造UpperClass 加入类对象作为成员：

class UpperClass
{
public:
	int a;
	DownClass b;
	int c;
};

struct UpperStruct
{
public:
	int a;
	DownClass b;
	int c;
};

运行test01得到的结果：

void Test01()
{
    UpperClass upperClass1;
    UpperStruct upperStruct1;

    upperClass1.a = 100;
    upperStruct1.a = 200;
    DownClass dc1{1,1,1};
    upperClass1.b = dc1;
    upperStruct1.b = dc1;

    cout << "up1地址：" << (int)&upperClass1 << ";up1大小" << sizeof(upperClass1) << endl;
    cout << "dc1地址：" << (int)&dc1 << ";dc1大小" << sizeof(dc1) << endl;
    cout << "up1-a地址：" << (int)&upperClass1.a << ";up1-a大小" << sizeof(upperClass1.a) << endl;
    cout << "up1-b地址：" << (int)&upperClass1.b << ";up1-b大小" << sizeof(upperClass1.b) << endl;
    cout << "us1地址：" << (int)&upperStruct1 << ";us1大小" << sizeof(upperStruct1) << endl;
    cout << "us1-a地址：" << (int)&upperStruct1.a << ";us1-a大小" << sizeof(upperStruct1.a) << endl;
    cout << "us1-b地址：" << (int)&upperStruct1.b << ";us1-b大小" << sizeof(upperStruct1.b)<<endl;

    cout << "**********************************************************************" << endl;
    UpperClass* upperClass2= new UpperClass();
    UpperStruct* upperStruct2= new UpperStruct();

    upperClass2->a = 100;
    upperStruct2->a = 200;
    DownClass* dc2 = new DownClass();
    upperClass2->b = *dc2;
    upperStruct2->b = *dc2;
    
    cout << "up2地址：" << (int)upperClass2 << ";up2大小" << sizeof(*upperClass2) << endl;
    cout << "dc2地址：" << (int)dc2 << ";dc大小" << sizeof(*dc2) << endl;
    cout << "up2-a地址：" << (int)&upperClass2->a << ";up2-a大小" << sizeof(upperClass2->a) << endl;
    cout << "up2-b地址：" << (int)&upperClass2->b << ";up2-b大小" << sizeof(upperClass2->b) << endl;
    cout << "us2地址：" << (int)upperStruct2 << ";us2大小" << sizeof(*upperStruct2) << endl;
    cout << "us2-a地址：" << (int)&upperStruct2->a << ";us2-a大小" << sizeof(upperStruct2->a) << endl;
    cout << "us2-b地址：" << (int)&upperStruct2->b << ";us2-b大小" << sizeof(upperStruct2->b) << endl;
}

up1地址：1970666848;up1大小20
dc1地址：1970666832;dc1大小12
up1-a地址：1970666848;up1-a大小4
up1-b地址：1970666852;up1-b大小12
us1地址：1970666872;us1大小20
us1-a地址：1970666872;us1-a大小4
us1-b地址：1970666876;us1-b大小12
**********************************************************************
up2地址：-1795421584;up2大小20
dc2地址：-1795422000;dc大小12
up2-a地址：-1795421584;up2-a大小4
up2-b地址：-1795421580;up2-b大小12
us2地址：-1795420592;us2大小20
us2-a地址：-1795420592;us2-a大小4
us2-b地址：-1795420588;us2-b大小12

结论：class和struct在内存中的大小包含其中成员类的大小，类的成员对象通过赋值操作后将外部定义的对象拷贝到类的地址内

查看堆和栈之间的数据交互

运行Test02，通过栈堆调用

void Test02()
{
    UpperClass upperClass1;
    UpperStruct upperStruct1;

    upperClass1.a = 100;
    upperStruct1.a = 200;

    DownClass* dc1 = new DownClass();

    upperClass1.b = *dc1;
    upperStruct1.b = *dc1;

    cout << "up1地址：" << (int)&upperClass1 << ";up1大小" << sizeof(upperClass1) << endl;
    cout << "dc1地址：" << (int)dc1 << ";dc1大小" << sizeof(*dc1) << endl;
    cout << "up1-a地址：" << (int)&upperClass1.a << ";up1-a大小" << sizeof(upperClass1.a) << endl;
    cout << "up1-b地址：" << (int)&upperClass1.b << ";up1-b大小" << sizeof(upperClass1.b) << endl;
    cout << "us1地址：" << (int)&upperStruct1 << ";us1大小" << sizeof(upperStruct1) << endl;
    cout << "us1-a地址：" << (int)&upperStruct1.a << ";us1-a大小" << sizeof(upperStruct1.a) << endl;
    cout << "us1-b地址：" << (int)&upperStruct1.b << ";us1-b大小" << sizeof(upperStruct1.b) << endl;

    cout << "**********************************************************************" << endl;
    UpperClass* upperClass2 = new UpperClass();
    UpperStruct* upperStruct2 = new UpperStruct();

    upperClass2->a = 100;
    upperStruct2->a = 200;

    DownClass dc2;

    cout << "up2地址：" << (int)upperClass2 << ";up2大小" << sizeof(*upperClass2) << endl;
    cout << "dc2地址：" << (int)&dc2 << ";dc大小" << sizeof(dc2) << endl;
    cout << "up2-a地址：" << (int)&upperClass2->a << ";up2-a大小" << sizeof(upperClass2->a) << endl;
    cout << "up2-b地址：" << (int)&upperClass2->b << ";up2-b大小" << sizeof(upperClass2->b) << endl;
    cout << "us2地址：" << (int)upperStruct2 << ";us2大小" << sizeof(*upperStruct2) << endl;
    cout << "us2-a地址：" << (int)&upperStruct2->a << ";us2-a大小" << sizeof(upperStruct2->a) << endl;
    cout << "us2-b地址：" << (int)&upperStruct2->b << ";us2-b大小" << sizeof(upperStruct2->b) << endl;
}

运行结果：

up1地址：-737085216;up1大小20
dc1地址：213126032;dc1大小12
up1-a地址：-737085216;up1-a大小4
up1-b地址：-737085212;up1-b大小12
us1地址：-737085192;us1大小20
us1-a地址：-737085192;us1-a大小4
us1-b地址：-737085188;us1-b大小12
**********************************************************************
up2地址：213125904;up2大小20
dc2地址：-737085168;dc大小12
up2-a地址：213125904;up2-a大小4
up2-b地址：213125908;up2-b大小12
us2地址：213125936;us2大小20
us2-a地址：213125936;us2-a大小4
us2-b地址：213125940;us2-b大小12

可以发现，dc1通过new创建，存在于堆区。up1及us1均在栈区，通过赋值操作，将存在于堆区的dc1拷贝到栈区；

dc2在栈区创建，up2及us2均在堆区，通过复制操作，将存在于栈区的dc2拷贝到堆区的类对象内。

##父类与子类的交互

如Test03（）

void Test03()
{
    UpperClass upperClass1;
    UpperStruct upperStruct1;

    upperClass1.a = 100;
    upperStruct1.a = 200;

    DownClass* dc1 = new DownTClass();
    DownTClass* dc3 = new DownTClass();

    upperClass1.b = *dc3;
    upperStruct1.b =*dc3;

    cout << "up1地址：" << (int)&upperClass1 << ";up1大小" << sizeof(upperClass1) << endl;
    cout << "dc1地址：" << (int)dc1 << ";dc1大小" << sizeof(*dc1) << endl;
    cout << "dc3地址：" << (int)dc3 << ";dc3大小" << sizeof(*dc3) << endl;
    cout << "up1-a地址：" << (int)&upperClass1.a << ";up1-a大小" << sizeof(upperClass1.a) << endl;
    cout << "up1-b地址：" << (int)&upperClass1.b << ";up1-b大小" << sizeof(upperClass1.b) << endl;
    cout << "us1地址：" << (int)&upperStruct1 << ";us1大小" << sizeof(upperStruct1) << endl;
    cout << "us1-a地址：" << (int)&upperStruct1.a << ";us1-a大小" << sizeof(upperStruct1.a) << endl;
    cout << "us1-b地址：" << (int)&upperStruct1.b << ";us1-b大小" << sizeof(upperStruct1.b) << endl;

    cout << "**********************************************************************" << endl;
    UpperClass* upperClass2 = new UpperClass();
    UpperStruct* upperStruct2 = new UpperStruct();

    upperClass2->a = 100;
    upperStruct2->a = 200;

    DownClass dc2{1,1,1};
    upperClass2->b = dc2;
    upperStruct2->b = dc2;

    cout << "up2地址：" << (int)upperClass2 << ";up2大小" << sizeof(*upperClass2) << endl;
    cout << "dc2地址：" << (int)&dc2 << ";dc大小" << sizeof(dc2) << endl;
    cout << "up2-a地址：" << (int)&upperClass2->a << ";up2-a大小" << sizeof(upperClass2->a) << endl;
    cout << "up2-b地址：" << (int)&upperClass2->b << ";up2-b大小" << sizeof(upperClass2->b) << endl;
    cout << "us2地址：" << (int)upperStruct2 << ";us2大小" << sizeof(*upperStruct2) << endl;
    cout << "us2-a地址：" << (int)&upperStruct2->a << ";us2-a大小" << sizeof(upperStruct2->a) << endl;
    cout << "us2-b地址：" << (int)&upperStruct2->b << ";us2-b大小" << sizeof(upperStruct2->b) << endl;
}

程序运行结果：

void Test03()
{
    UpperClass upperClass1;
    UpperStruct upperStruct1;

    upperClass1.a = 100;
    upperStruct1.a = 200;

    DownClass* dc1 = new DownTClass();
    DownTClass* dc3 = new DownTClass();

    upperClass1.b = *dc3;
    upperStruct1.b =*dc3;

    cout << "up1地址：" << (int)&upperClass1 << ";up1大小" << sizeof(upperClass1) << endl;
    cout << "dc1地址：" << (int)dc1 << ";dc1大小" << sizeof(*dc1) << endl;
    cout << "dc3地址：" << (int)dc3 << ";dc3大小" << sizeof(*dc3) << endl;
    cout << "up1-a地址：" << (int)&upperClass1.a << ";up1-a大小" << sizeof(upperClass1.a) << endl;
    cout << "up1-b地址：" << (int)&upperClass1.b << ";up1-b大小" << sizeof(upperClass1.b) << endl;
    cout << "us1地址：" << (int)&upperStruct1 << ";us1大小" << sizeof(upperStruct1) << endl;
    cout << "us1-a地址：" << (int)&upperStruct1.a << ";us1-a大小" << sizeof(upperStruct1.a) << endl;
    cout << "us1-b地址：" << (int)&upperStruct1.b << ";us1-b大小" << sizeof(upperStruct1.b) << endl;

    cout << "**********************************************************************" << endl;
    UpperClass* upperClass2 = new UpperClass();
    UpperStruct* upperStruct2 = new UpperStruct();

    upperClass2->a = 100;
    upperStruct2->a = 200;

    DownClass dc2{1,1,1};
    upperClass2->b = dc2;
    upperStruct2->b = dc2;

    cout << "up2地址：" << (int)upperClass2 << ";up2大小" << sizeof(*upperClass2) << endl;
    cout << "dc2地址：" << (int)&dc2 << ";dc大小" << sizeof(dc2) << endl;
    cout << "up2-a地址：" << (int)&upperClass2->a << ";up2-a大小" << sizeof(upperClass2->a) << endl;
    cout << "up2-b地址：" << (int)&upperClass2->b << ";up2-b大小" << sizeof(upperClass2->b) << endl;
    cout << "us2地址：" << (int)upperStruct2 << ";us2大小" << sizeof(*upperStruct2) << endl;
    cout << "us2-a地址：" << (int)&upperStruct2->a << ";us2-a大小" << sizeof(upperStruct2->a) << endl;
    cout << "us2-b地址：" << (int)&upperStruct2->b << ";us2-b大小" << sizeof(upperStruct2->b) << endl;
}

运行结果

up1地址：-1854210944;up1大小20
dc1地址：1278937264;dc1大小12
dc3地址：1278938800;dc3大小24
up1-a地址：-1854210944;up1-a大小4
up1-b地址：-1854210940;up1-b大小12
us1地址：-1854210920;us1大小20
us1-a地址：-1854210920;us1-a大小4
us1-b地址：-1854210916;us1-b大小12
**********************************************************************
up2地址：1278937296;up2大小20
dc2地址：-1854210960;dc大小12
up2-a地址：1278937296;up2-a大小4
up2-b地址：1278937300;up2-b大小12
us2地址：1278937008;us2大小20
us2-a地址：1278937008;us2-a大小4
us2-b地址：1278937012;us2-b大小12

结论：
当用父类声明，用子类新建实例时，子类中的对象成员会消失。
因此在class中声明有继承关系的成员对象时，需要用到指针。
将对象单独声明出来，进行统一管理。

有个奇怪的问题：

在虚拟机上sizeof一个类永远都是8个字节，但是在本地运行是真实大小。

传递参数时，通过const MyParentClass& 来引用对象可以保证子类数据的完整性

通过智能指针管理内存

shared_ptr

unique_ptr

数据之间的传递

接下来构造以下类

#pragma once
#include <iostream>
#include <string>
#include <vector>
using namespace std;

enum PersonType
{
	per,
	tea,
};
class Person
{
public:
	Person();
	Person(const Person& src);
	~Person();
	Person& Clone(const Person& oriPer);
	int name;
	int age;
	PersonType type;
};

class Teacher:public Person
{
public:
	Teacher();
	Teacher(const Teacher& teacher);
	~Teacher();
	int school;
};

class School
{
public:
	School();
	vector<Teacher>* teacherList;
};


#include "CloneTest.h"

Person::Person()
{
	this->type = PersonType::per;
}
Person::Person(const Person& src):type(src.type),
name(src.name),
age(src.age)
{
}
Person::~Person()
{
}
Person& Person::Clone(const Person& oriPer)
{
	if (oriPer.type == PersonType::tea)
	{
		Teacher ori = *(Teacher*)&oriPer;
		Teacher newP = Teacher(ori);
		return newP;
	}
	else
	{
		Person newP = Person(oriPer);
		return newP;
	}
}

Teacher::Teacher()
{
	this->type = PersonType::tea;
}
Teacher::Teacher(const Teacher& src):Person(src),
school(src.school)
{
}
Teacher::~Teacher()
{
}
School::School()
{
	this->teacherList = new vector<Teacher>();
}

两个类中，teacher类继承person类，clone函数通过返回引用，可以返回对象的指针：

void TestClone()
{
    Teacher p2;
    p2.age = 20;
    p2.name =3;
    p2.school = 4;

    Person& p3 = p2.Clone(p2);

    
    std::cout << "P2地址：" << (int)&p2 << endl;
    std::cout << "P3地址：" << (int)&p3 << endl;

    Teacher p4 = *(Teacher*)(&p3);
    std::cout << "P4地址：" << (int)&p3 << endl;
    std::cout << "P4school：" << p4.school << endl;

}

通过以下
Teacher p4 = (Teacher)(&p3);
指针格式转换，可以转换数据格式
得到以下结果：

P2地址：577763184
P3地址：577763200
P4地址：577763200
P4school：4

说明数据格式转换成功；

###类中的成员对象在堆和栈中的区分：

测试以下两个函数

void TestCloneAdress01()
{
    Teacher p2;
    p2.age = 20;
    p2.name = 3;
    p2.school = 4;
    School school;

    school.teacherList->push_back(p2);
    std::cout << "ori teacher addres：" << (int)&p2 << endl;
    std::cout << "school adress：" << (int)&school << endl;
    std::cout << "teacher list adress：" << (int)school.teacherList << endl;
    std::cout << "teacher adress：" << (int)&school.teacherList->at(0) << endl;
}
void TestCloneAdress02()
{
    Teacher p4;
    p4.age = 210;
    p4.name = 33;
    p4.school = 43;
    School* school= new School();

    school->teacherList->push_back(p4);

    std::cout << "ori teacher addres：" << (int)&p4 << endl;
    std::cout << "school adress：" << (int)school << endl;
    std::cout << "teacher list adress：" << (int)school->teacherList << endl;
    std::cout << "teacher adress：" << (int)&school->teacherList->at(0) << endl;
}

得到以下结果：

ori teacher addres：-783090680
school adress：-783090688
teacher list adress：1398148368
teacher adress：1398149200
**************************************************
ori teacher addres：-783090680
school adress：1398146448
teacher list adress：1398148208
teacher adress：1398149296

可以发现，school类中的teacher是开辟在堆中的，因此它的子成员也都存在于堆中，
原始定义的数据通过数据的传递复制到堆中

parleychou
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C/C++内存管理
Rinki123456的博客
06-01 186
在C语言中提供了三个方式来动态开辟空间，分别是malloc、calloc、realloc，那他们三者有什么区别呢？ malloc：在堆上开辟空间，但对开辟的空间不进行初始化。calloc：在堆上开辟空间，并对开辟的空间进行初始化，如果是int等类型则初始化为0，如果是指针类型则初始化为NULL。realloc：对已开辟的空间进行扩充或者缩小，如果是进行扩充，已开辟空间的内容会被保存，如果是进行缩小，可能会丢失原空间的内容。C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因
c++动态内存管理
LXY的博客
11-07 367
c/c++内存分布 int globalVar = 1; static int staticGlobalVar = 1; void Test() { static int staticVar = 1; int localVar = 1; int num1[10] = {1, 2, 3, 4}; char char2[] = "abcd"; ...
C/C++编程之内存管理
指尖飞舞
01-29 1816
内存分配方式 内存分配方式一共有三种： （1）从静态存储区域分配； 内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在，例如，全局变量，静态变量。 （2）在栈上创建； 在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束后这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。 （3）在堆上分配，亦称动态内存
C++【内存管理】
芊樱烛渊的博客
08-06 291
;int main(){// new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间//还会调用构造函数和析构函数//这里在堆上开辟空间的时候还会调用构造函数对我们的对象进行初始化。free(p1);delete p2;// 内置类型是几乎是一样的// C//free仅仅是释放空间free(p3);......
C++内存管理（很全，例子很详细）
yhc166188的博客
06-16 380
C++内存管理详解l内存分配方式在C++中,内存分成5个区,分别是堆、栈、自由存储区、全局/静态区和常量存储区.栈:存放函数参数以及局部变量,在出作用域时,将自动被释放.栈内存分配运算内置于处理器的指令集中,效率很高,但分配的内存容量有限.堆:new分配的内存块(包括数组,类实例等),需delete手动释放.如果未释放,在整个程序结束后,OS会帮你回收掉.自由存储区:mallo...
C++内存管理机制笔记
最新发布
04-13
C++内存管理机制笔记
C++内存管理技术内幕
08-25
C++内存管理技术内幕 pdf
C++ 内存管理
02-20
C++ 内存管理 C++ 中的内存管理是指在 C++ 环境中如何管理内存的资源的。内存管理是指程序对内存的申请、使用和释放。C++ 中的内存管理可以分为五个部分：栈、堆、自由存储区、全局/静态存储区和常量存储区。 1. ...
内存管理源码
12-22
设计结构体模拟物理内存块 分别模拟FF、BF、WF三种适应算法动态地创建进程 能够动态地销毁进程并更新可用表与已分配表 显示出各个时间段内存块中已分配表与可用表的情况
【C++】内存管理
m0_62179366的博客
08-07 572
内存泄漏（Memory Leak）是指程序中已动态分配的堆内存由于某种原因程序未释放或无法释放，造成系统内存的浪费，导致程序运行速度减慢甚至系统崩溃等严重后果。内存泄漏缺陷具有隐蔽性、积累性的特征，比其他内存非法访问错误更难检测。因为内存泄漏的产生原因是内存块未被释放，属于遗漏型缺陷而不是过错型缺陷。此外，内存泄漏通常不会直接产生可观察的错误症状，而是逐渐积累，降低系统整体性能，极端的情况下可能使系统崩溃。...
C++内存管理（内含面试题：C和C++的区别，new 和delete的底层原理）
落叶知秋深的博客
07-20 4729
1、new/delete、new[]/delete[] new、delete是操作符，用来分配空间和清理对象的。new[]、delete[]是来为对象数组分配空间和清理对象的。 int* p1=new int;//分配一个int大小的空间 int* p2=new int(3);//分配一块空间，并将空间初始化成3. int* p3=new int[3];//分配3个int对象的空间。 ...
C++实现简单的内存块自动管理
weeks
07-26 1281
#ifndef __MEM__H #define __MEM__H #include using namespace std; //自动管理内存块 typedef unsigned char byte; class Mem { private: byte* mem; int size; void ensureMinSize(int minSize); public: Mem();
C++ 内存管理（一）
Francis的博客
09-06 1079
C++ 内存管理（一）导语c++ 内存管理学习自侯捷。下面是本次对C++内存管理一些笔记。1.四种内存分配与释放在编程时可以通过上图的几种方法直接或间接地操作内存。下面将...
C++之内存管理
疯狂的石头
06-20 2853
哈佛结构和冯诺依曼结构的主要区别就是处理器能不能实现取指令和取数据的并发进行。嵌入式芯片中主要是哈佛结构，PC机上是冯诺依曼结构。 经典的哈佛结构： 程序存储器和数据存储器是各自独立的存储器。处理器应该有两套总线，一套是程序存储器的数据和地址总线，一套是数据存储器的数据和地址总线。取指令和取数据能并发进行。51的程序进程的逻辑代码段放在ROM中，而变量部分则放在RAM中，取ROM中的指令和RAM...
【C++】动态内存管理
码农印象
11-10 361
前言一、C/C++内存分布二、回顾C语言中的动态内存管理1. malloc/calloc/realloc的区别是什么？2. 32位平台指针为什么是4个字节？3. 如何malloc一个大于3G的空间？三、C++中的内存管理1. new/delete操作内置类型用法2. new/delete操作自定义类型用法四、operator new和operator delete函数五、定位new表达式六、常见面...
C++内存管理深度解析
"C++内存管理pdf版，详细讲解了C++的内存管理模式，包括内存管理、内存泄漏和内存回收三个方面的内容。" 在C++编程中，内存管理是一项至关重要的技能，它涉及到程序的性能、稳定性和资源的有效利用。C++提供了对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值