C++内存管理

已于 2022-06-13 10:57:08 修改
阅读量1k 收藏 4
点赞数
分类专栏： C++学习 文章标签： c++ 开发语言
于 2022-06-13 10:54:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44623662/article/details/125253335
版权

1.C/C++内存分布

在这里插入图片描述
【说明】

  1. 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。
  2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享内存，做进程间通信。
  3. 堆用于程序运行时动态内存分配，堆是可以上增长的。
  4. 数据段– 存储全局数据和静态数据 。
  5. 代码段–** 可执行的代码/只读常量** 。

2. C语言中动态内存管理方式

2.1. malloc/calloc/realloc和free

void Test ()
{
 	int* p1 = (int*) malloc(sizeof(int));
 	free(p1);
 
 	// 1.malloc/calloc/realloc的区别是什么？
 	int* p2 = (int*)calloc(4, sizeof (int));
 	int* p3 = (int*)realloc(p2, sizeof(int)*10);
 
 	// 这里需要free(p2)吗？
 	free(p3 );
}

面试题
malloc/calloc/realloc的区别？
<1>alloca是向栈申请内存,因此无需释放.
<2>malloc分配的内存是位于堆中的,并且没有初始化内存的内容,因此基本上malloc之后,调用函数memset来初始化这部分的内存空间.
<3>calloc则将初始化这部分的内存,设置为0.
<4>realloc则对malloc申请的内存进行大小的调整.
<5>申请的内存最终需要通过函数free来释放.
当程序运行过程中malloc了,但是没有free的话,会造成内存泄漏.一部分的内存没有被使用,但是由于没有free,因此系统认为这部分内存还在使用,造成不断的向系统申请内存,使得系统可用内存不断减少.但是内存泄漏仅仅指程序在运行时,程序退出时,OS将回收所有的资源.因此,适当的重起一下程序,有时候还是有点作用.

三个函数的申明分别是:
void* malloc(unsigned size);
void* realloc(void* ptr, unsigned newsize);
void* calloc(size_t numElements, size_t sizeOfElement);

都在stdlib.h函数库内，它们的返回值都是请求系统分配的地址,如果请求失败就返回NULL.
(1)函数malloc()
在内存的动态存储区中分配一块长度为size字节的连续区域，参数size为需要内存空间的长度，返回该区域的首地址.
(2)函数calloc()
与malloc相似,参数sizeOfElement为申请地址的单位元素长度,numElements为元素个数，即在内存中申请numElementssizeOfElement字节大小的连续地址空间.
(3)函数realloc()
给一个已经分配了地址的指针重新分配空间,参数ptr为原有的空间地址,newsize是重新申请的地址长度.
区别
(1) 函数malloc不能初始化所分配的内存空间,而函数calloc能.如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是0;反之, 如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据.也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行,但经过一段时间(内存空间还已经被重新分配)可能会出现问题.
(2) 函数calloc() 会将所分配的内存空间中的每一位都初始化为零,也就是说,如果你是为字符类型或整数类型的元素分配内存,那么这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那么这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零.
(3)函数malloc向系统申请分配指定size个字节的内存空间.返回类型是 void类型.void表示未确定类型的指针.C,C++规定，void 类型可以强制转换为任何其它类型的指针.
(4) realloc可以对给定的指针所指的空间进行扩大或者缩小，无论是扩张或是缩小，原有内存的中内容将保持不变.当然，对于缩小，则被缩小的那一部分的内容会丢失.realloc并不保证调整后的内存空间和原来的内存空间保持同一内存地址.相反，realloc返回的指针很可能指向一个新的地址.
(5) realloc是从堆上分配内存的.当扩大一块内存空间时，realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平；如果数据后面的字节不够，问题就出来了，那么就使用堆上第一个有足够大小的自由块，现存的数据然后就被拷贝至新的位置，而老块则放回到堆上.这句话传递的一个重要的信息就是数据可能被移动.
参考

3. C++中动态内存管理

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

3.1. new/delete操作内置类型

int main()
{
 	// 动态申请一个int类型的空间
	 int* ptr4 = new int;
 
	 // 动态申请一个int类型的空间并初始化为10
	 int* ptr5 = new int(10);
 
 	// 动态申请10个int类型的空间
	 int* ptr6 = new int[10];
 
 	 delete ptr4;
	 delete ptr5;
	 delete[] ptr6; 
 }

在这里插入图片描述
注意：申请和释放单个元素的空间，使用new和delete操作符，申请和释放连续的空间，使用new[]和delete[]

3.2. new和delete操作自定义类型

#include<iostream>
#include<cstdlib>
using namespace std;

class Test
{
	public:
		Test()
			:_data(0)
		{
			cout << "Test():" << this << endl;
		}
		~Test(){
			cout << "~Test():" << this << endl; 
		}
	private:
		int _data;
};
void Test1(){
	// 申请单个Test类型的空间
	Test* p1 = (Test*)malloc(sizeof(Test));
	free(p1);
	
	// 申请10个Test类型的空间
	Test* p2 = (Test*)malloc(sizeof(Test) * 10);
	free(p2);
} 

void Test2(){
	// 申请单个Test类型的对象
	Test* p1 = new Test;
	delete p1;
	
	// 申请10个Test类型的对象
	Test* p2 = new Test[10];
	delete[] p2;
}

int main(){
	Test2();
	return 0;
}

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

4. operator new与operator delete函数

4.1 operator new与operator delete函数（重点）

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，尝试执行空间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。
*/
void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc) {
 	// try to allocate size bytes
 	void *p;
 	while ((p = malloc(size)) == 0)
 		if (_callnewh(size) == 0)
 		{
 			// report no memory
 			// 如果申请内存失败了，这里会抛出bad_alloc 类型异常
			static const std::bad_alloc nomem;
			_RAISE(nomem);
		}
 	return (p);
}
/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void *pUserData) {
 	_CrtMemBlockHeader * pHead;
 	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
 	if (pUserData == NULL)
		return;
	 _mlock(_HEAP_LOCK); /* block other threads */
	 __TRY
 		/* get a pointer to memory block header */
		 pHead = pHdr(pUserData);
		 /* verify block type */
 		_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
		 _free_dbg( pUserData, pHead->nBlockUse );
		 __FINALLY
	 _munlock(_HEAP_LOCK); /* release other threads */
	 __END_TRY_FINALLY
	 return; }
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

4.2 operator new与operator delete的类专属重载（了解）

下面代码演示了，针对链表的节点ListNode通过重载类专属 operator new/ operator delete，实现链表节点使用内存池申请和释放内存，提高效率。

struct ListNode
{
	 ListNode* _next;
	 ListNode* _prev;
	 int _data;
 	void* operator new(size_t n)
 	{
		 void* p = nullptr;
		 p = allocator<ListNode>().allocate(1);
		 cout << "memory pool allocate" << endl;
		 return p;
	 }
	 void operator delete(void* p)
	 {
		 allocator<ListNode>().deallocate((ListNode*)p, 1);
		 cout << "memory pool deallocate" << endl;
	  }
};
class List
{
	public:
		 List()
		 {
			 _head = new ListNode;
			 _head->_next = _head;
			 _head->_prev = _head;
		 }
		 ~List()
		 {
			 ListNode* cur = _head->_next;
			 while (cur != _head)
			 {
				 ListNode* next = cur->_next;
				 delete cur;
				 cur = next;
			 }
			 delete _head;
			 _head = nullptr;
		 }
private:
	 ListNode* _head;
};
int main()
{
	 List l;
	 return 0; 
}

5. new和delete的实现原理

5.1. 内置类型

如果申请的是内置类型的空间，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

5.2 自定义类型

  • new的原理
  1. 调用operator new函数申请空间
  2. 在申请的空间上执行构造函数，完成对象的构造
  • delete的原理
  1. 在空间上执行析构函数，完成对象中资源的清理工作
  2. 调用operator delete函数释放对象的空间
  • new T[N]的原理
  1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请
  2. 在申请的空间上执行N次构造函数
  • delete[]的原理
  1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理
  2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

6. 定位new表达式(placement-new)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式：
new (place_address) type或者new (place_address) type(initializer-list)
place_address必须是一个指针，initializer-list是类型的初始化列表
使用场景：
定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

class Test
{
	public:
		 Test()
			 : _data(0)
		 {
			 cout<<"Test():"<<this<<endl;
		 }
		 ~Test()
		 {
			 cout<<"~Test():"<<this<<endl;
		 }
 
	private:
 		int _data;
};
void Test()
{
 	// pt现在指向的只不过是与Test对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行
 	Test* pt = (Test*)malloc(sizeof(Test));
	new(pt) Test; // 注意：如果Test类的构造函数有参数时，此处需要传参
}

malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：

  1. malloc和free是函数，new和delete是操作符
  2. malloc申请的空间不会初始化，new可以初始化
  3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
  4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型
  5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常
  6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

请设计一个类，该类只能在堆上创建对象

方法一：构造函数私有化

  1. 将类的构造函数私有，拷贝构造声明成私有。防止别人调用拷贝在栈上生成对象。
  2. 提供一个静态的成员函数，在该静态成员函数中完成堆对象的创建
class HeapOnly 
{ 
	public: 
 		static HeapOnly* CreateObject() 
 		{ 
 			return new HeapOnly; 
 		}
	private: 
		 HeapOnly() {}
 
		 // C++98
		 // 1.只声明,不实现。因为实现可能会很麻烦，而你本身不需要
		 // 2.声明成私有
 		HeapOnly(const HeapOnly&)；
 
		 // or
 
		 // C++11 
		 HeapOnly(const HeapOnly&) = delete;
};

请设计一个类，该类只能在栈上创建对象

class StackOnly 
{ 
public: 
 	static StackOnly CreateObject() 
 	{ 
 		return StackOnly(); 
 	}
private:
 	StackOnly() {}
};

只能在栈上创建对象，即不能在堆上创建，因此只要将new的功能屏蔽掉即可，即屏蔽掉operator new和定位new表达式，注意：屏蔽了operator new，实际也将定位new屏蔽掉。

class StackOnly 
{ 
public: 
	 StackOnly() {}
private: 
 	void* operator new(size_t size);
	void operator delete(void* p);
};

单例模式

设计模式：
设计模式（Design Pattern）是一套被反复使用、多数人知晓的、经过分类的、代码设计经验的总结。为什么会产生设计模式这样的东西呢？就像人类历史发展会产生兵法。最开始部落之间打仗时都是人拼人的对砍。后来春秋战国时期，七国之间经常打仗，就发现打仗也是有套路的，后来孙子就总结出了《孙子兵
法》。孙子兵法也是类似。
使用设计模式的目的：为了代码可重用性、让代码更容易被他人理解、保证代码可靠性。 设计模式使代码编写真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。
单例模式：
一个类只能创建一个对象，即单例模式，该模式可以保证系统中该类只有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享。 比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息，这种方式简化了在复杂环境下的配置管理。

单例模式有两种实现模式：
饿汉模式
就是说不管你将来用不用，程序启动时就创建一个唯一的实例对象。

// 优点：简单
// 缺点：可能会导致进程启动慢，且如果有多个单例类对象实例启动顺序不确定。
 class Singleton
 {
 public:
 	static Singleton* GetInstance()
 	{
	 return &m_instance;
	 }
 
 private:
	 // 构造函数私有
	 Singleton(){};
 
	 // C++98 防拷贝
	 Singleton(Singleton const&); 
	 Singleton& operator=(Singleton const&); 
 
 	// or
 
	 // C++11
	 Singleton(Singleton const&) = delete; 
	 Singleton& operator=(Singleton const&) = delete; 
 
	 static Singleton m_instance;
 };
 
 Singleton Singleton::m_instance; // 在程序入口之前就完成单例对象的初始化

如果这个单例对象在多线程高并发环境下频繁使用，性能要求较高，那么显然使用饿汉模式来避免资源竞争，提高响应速度更好。

懒汉模式
如果单例对象构造十分耗时或者占用很多资源，比如加载插件啊， 初始化网络连接啊，读取文件啊等等，而有可能该对象程序运行时不会用到，那么也要在程序一开始就进行初始化，就会导致程序启动时非常的缓慢。 所以这种情况使用懒汉模式（延迟加载）更好。

#include<iostream>
#include<mutex>
#include<thread>
using namespace std;

class Singleton{
	public:
		static Singleton* GetInstance(){
			// 注意这里一定要使用Double-Check的方式加锁，才能保证效率和线程安全
			if (nullptr == m_pInstance){
				m_mtx.lock();
				if (nullptr == m_pInstance){
					m_pInstance = new Singleton();
				}
				m_mtx.unlock();
			}
			return m_pInstance;
		}
		
		// 实现一个内嵌垃圾回收类
		class CGarbo{
			public:
				~CGarbp(){
					if (Singleton::m_pInstance){
						delete Singleton::m_pInstance;
					}
				}
		};
		// 定义一个静态成员变量，程序结束时，系统会自动调用它的析构函数从而释放单例对象
		static CGarbo Garbo;
	private:
		// 构造函数私有
		Singleton(){
		};
		// 防拷贝
		Singleton(Singleton const&);
		Singleton& operator=(Singleton const&);
		static Singleton* m_pInstance; // 单例对象指针
		static mutex m_mtx; //互斥锁
};

Singleton* Singleton::m_pInstance = nullptr;
Singleton::CGarbo Garbo;
mutex Singleton::m_mtx;

void func(int n){
	cout << Singleton::GetInstance() << endl;
	
}
// 多线程环境下演示上面GetInstance()加锁和不加锁的区别。
int main()
{
	thread t1(func, 10);
	thread t2(func, 10);
	t1.join();
	t2.join();
	cout << Singleton::GetInstance() << endl;
	cout << Singleton::GetInstance() << endl;
	
	return 0;
}

内存泄漏

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

内存泄漏分类

  • 堆内存泄漏(Heap leak)
    堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
  • 系统资源泄漏
    指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何避免内存泄漏

  1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保
    证。
  2. 采用RAII思想或者智能指针来管理资源。
  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
  4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

总结一下:
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

小小草帽
关注
专栏目录
【C++】C/C++的内存管理方式
丁丁逗的博客
10-20 536
1. 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"; char* pChar3 = "abcd"; int* ptr1 = (int*)malloc(sizeof (int)* 4); int* pt
【C++】内存管理
最新发布
春风不语。
09-06 1131
到这里就结束了，本篇主要讲解了C/C++内存分布以及可能出现的问题，希望对大家有所帮助，有不足的地方多多指正，祝大家天天开心！
C++的内存管理
热门推荐
bizhu的专栏
08-08 3万+
这篇文章是我在学习高质量C++/C编程指南中的第7章"内存管理"后的一篇笔记,之前我也写过相关的文章指针以及内存分配,但我感觉那篇还不是很好,这篇我很把它更完善一些 一.内存的常见分配方式   1. 从静态区分配,一般是全局变量和static类型变量   2.从栈区分配内存
c++ 内存管理
m0_62211222的博客
10-04 448
在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。
C++中动态内存管理（new/delete的实现）
zhao_leilei的博客
10-14 1064
1.复习C语言中动态内存管理： C语言动态内存管理 2.C++内存管理方式 C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。 new/delete代码演示： ...
c++内存管理
weixin_49312527的博客
04-04 6611
一.c/c++内存分布 1.c/c++内存区域划分 我们直接来看c/c++中的内存区域划分. 2.各个区域的功能 ①.内核空间:操作系统内核代码的运行空间. ②.栈:又叫做堆栈,非静态局部变量/函数形参/返回值/表达式中间结果/某些寄存器信息等等,栈是向下增长的. ③.内存映射段: 是高效的I/O映射方式,用于装载一个共享的动态内存库,用户可以使用系统接口创建共享内存,进行进程间通信. ④.堆:用于程序运行时动态内存分配,堆是向上增长的. ⑤.数据段:存储全局数据和静态数据...
C++内存管理技术内幕
11-18
C++内存管理技术内幕涵盖了这一语言的核心机制之一。C++语言的内存管理之所以复杂，是因为它提供了自由分配和释放内存的能力，使得开发者可以精确控制程序的内存使用，但同时也增加了出错的可能性。以下是对上述文档...
一文秒懂C语言/C++内存管理(推荐)
12-16
C 语言内存管理指对系统内存的分配、创建、使用这一系列操作。在内存管理中，由于是操作系统内存，使用不当会造成毕竟麻烦的结果。本文将从系统内存的分配、创建出发，并且使用例子来举例说明内存管理不当会出现的...
C++内存管理学习资料.md
07-27
### C++内存管理学习资料概览 #### 一、引言 C++作为一种强大的编程语言，因其高效性和灵活性被广泛应用于各种领域。然而，这也带来了内存管理方面的挑战。本资料汇集了一系列关于C++内存管理的学习资源，旨在帮助...
经典收藏之 - C++内存管理详解
Chopin's nocturnes
05-22 1334
伟大的Bill Gates 曾经失言：　　640K ought to be enough for everybody — Bill Gates 1981 　　程序员们经常编写内存管理程序，往往提心吊胆。如果不想触雷，唯一的解决办法就是发现所有潜伏的地雷并且排除它们，躲是躲不了的。本文的内容比一般教科书的要深入得多，读者需细心阅读，做到真正地通晓内存管理。　　1、内存分配方式　　内存分配方式有三种：
c++之内存管理
nnluop的博客
06-04 141
C/C++内存管理内存分布c语言动态内存管理方式c++中动态内存管理方式operator new 和operator delete函数new和delete的实现原理 内存分布 c语言动态内存管理方式 c++中动态内存管理方式 operator new 和operator delete函数 new和delete的实现原理 1.内存分布 内存中分为栈、堆、数据段（静态区）、代码段。 栈又叫堆栈，非静态局部变量/函数参数/返回值等等，栈是向下增长的。 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存
内存管理
duoerbasilu
07-18 168
自动内存管理 在介绍自动手功内存管理之前，我们先介绍一下自动内存管理。 自动内存管理与局部变量相关，当程序执行时看到变量定义时，一个局部变量就开始占用系统内存了。当程序运行出定义局部变量的语句快时系统会自动释放局部变量所占的内存，事实上局部变量占用的是栈空间。 向下面的例子一样，程序员经常犯的一个错误就是返回一个无效的指针。一个内存释放后变量立即变的无效了。 int * badPointe...
C++——内存管理
luzhaoxi的博客
10-29 724
一、C/C++内存分布   在我们写代码时，会定义很多的变量，有静态的、全局的、局部的等等，但是这些变量在内存中是分别存放在不同的位置上； 二、C语言内存管理   在C语言中，我们是通过malloc/calloc/realloc来申请动态内存的，通过free来释放内存的； malloc：申请一块空间，对里面的内容不做任何处理； calloc：申请一块空间，并对立面的值全部初始化为0； realloc：对空间进行扩容，先申请一片更大的空间，再将原有空间的信息拷贝过来，最后再释放原有空间； free：对mal
C++之内存管理
疯狂的石头
06-20 2880
哈佛结构和冯诺依曼结构的主要区别就是处理器能不能实现取指令和取数据的并发进行。嵌入式芯片中主要是哈佛结构，PC机上是冯诺依曼结构。 经典的哈佛结构： 程序存储器和数据存储器是各自独立的存储器。处理器应该有两套总线，一套是程序存储器的数据和地址总线，一套是数据存储器的数据和地址总线。取指令和取数据能并发进行。51的程序进程的逻辑代码段放在ROM中，而变量部分则放在RAM中，取ROM中的指令和RAM...
C++内存管理深度解析
"C++内存管理pdf版，详细讲解了C++的内存管理模式，包括内存管理、内存泄漏和内存回收三个方面的内容。" 在C++编程中，内存管理是一项至关重要的技能，它涉及到程序的性能、稳定性和资源的有效利用。C++提供了对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值