69、自定义内存管理

已于 2023-02-08 20:00:57 修改
阅读量190 收藏
点赞数
分类专栏： C++ 文章标签： 自定义内存管理
于 2019-11-18 19:21:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiebs/article/details/103126927
版权

1、关键字 mutable

这个代码会出错，因为p没有初始化

#include <iostream>

using namespace std;

int main()
{
    int* p;
    (*p) = 1;
    cout << *p << endl;
    return 0;
}
  • 笔试题
    统计对象中某个成员变量的访问次数
#include <iostream>
#include <string>

using namespace std;

class Test
{
	int m_value;
	int m_count;
public:
	Test(int value = 0)
	{
		m_value = value;
		m_count = 0;
	}

	int getValue()const
	{
		m_count++;
		return m_value;
	}

	void setValue(int value)
	{
		m_value = value;
		m_count++;
	}

	int getCount()const
	{
		return m_count;
	}
};


int main()
{
	Test t(1);
	t.setValue(100);
	cout << "t.m_value = " << t.getValue() << endl;
	cout << t.getCount() << endl;

	const Test t2(20);
	cout << "t2.m_value = " << t2.getValue() << endl;
	cout << t2.getCount() << endl;
	return 0;
}

这个程序的问题在于可以解决普通对象中某个成员变量的访问次数问题，但是无法解决只读对象中成员变量的访问次数问题。在代码的第 19 行，我们在只读成员函数里面是不能修改成员变量的值的，于是，这样的写法肯定是不对的。

  • 遗失的关键字
    — mutable 是为了突破 const 函数的限制而设计的
    — mutable 成员变量将永远处于可改变的状态
    — mutable 在实际的项目开发中被严禁滥用
  • mutable 的深入分析
    — mutable 成员变量破坏了只读对象的内部状态
    — const 成员函数保证只读对象的状态不变性
    — mutable 成员变量的出现无法保证状态不变性
#include <iostream>
#include <string>

using namespace std;

class Test
{
	int m_value;
	mutable int m_count;
public:
	Test(int value = 0)
	{
		m_value = value;
		m_count = 0;
	}

	int getValue()const
	{
		m_count++;
		return m_value;
	}

	void setValue(int value)
	{
		m_value = value;
		m_count++;
	}

	int getCount()const
	{
		return m_count;
	}
};


int main()
{
	Test t(1);
	t.setValue(100);
	cout << "t.m_value = " << t.getValue() << endl;
	cout << t.getCount() << endl;

	const Test t2(20);
	cout << "t2.m_value = " << t2.getValue() << endl;
	cout << t2.getCount() << endl;
	return 0;
}

在这里插入图片描述
使用 mutable 可以解决我们的疑惑，但是建议不要这样用。

建议的用法：满足普通对象和只读对象的用法（这个代码存在问题，有一个函数没写成const）

#include <iostream>
#include <string>

using namespace std;

class Test
{
	int m_value;
	int* const m_Pcount;
	//mutable int m_count;
public:
	Test(int value = 0):m_Pcount(new int(0))
	{
		m_value = value;
		//m_count = 0;
	}

	int getValue()const
	{
		(*m_Pcount)++;
		//m_count++;
		return m_value;
	}

	void setValue(int value)
	{
		m_value = value;
		//m_count++;
		(*m_Pcount)++;
	}

	int getCount()const
	{
		//return m_count;
		return *m_Pcount;
	}
};

int main()
{
	Test t(1);
	t.setValue(100);
	cout << "t.m_value = " << t.getValue() << endl;
	cout << t.getCount() << endl;

	const Test t2(20);
	cout << "t2.m_value = " << t2.getValue() << endl;
	cout << t2.getCount() << endl;
	return 0;
}

在这里插入图片描述
或者这种写法：

#include <iostream>

using namespace std;

class Test
{
private:
    int m_value;
    int* p_cnt;
public:
    Test()
    {
        m_value = 0;
        p_cnt = new int(0);
    }

    void setValue(int value)
    {
        m_value = value;
        (*p_cnt)++;
    }

    int getValue()const
    {
        (*p_cnt)++;
        return m_value;
    }

    int getCnt()const
    {
        return *p_cnt;
    }

};

int main()
{
    Test t;
    t.setValue(10);
    cout << t.getValue() << endl;
    cout << t.getCnt() << endl;

    cout << endl;

    const Test tt;
    cout << tt.getValue() << endl;
    cout << tt.getCnt() << endl;

    return 0;
}

#include <iostream>

using namespace std;

#include <iostream>
#include <string>

using namespace std;

class Test
{
    int m_value;
    mutable int m_count;
public:
    Test(int value = 0)
    {
        m_value = value;
        m_count = 0;
    }

    int getValue()const
    {
        m_count++;
        return m_value;
    }

    void setValue(int value)const
    {
        int* p = const_cast<int*>(&m_value);
        *p = value;
        m_count++;
    }

    int getCount()const
    {
        return m_count;
    }
};


int main()
{
    Test t(1);
    t.setValue(100);
    cout << "t.m_value = " << t.getValue() << endl;
    cout << t.getCount() << endl;

    const Test t2(20);
    cout << "t2.m_value = " << t2.getValue() << endl;
    cout << t2.getCount() << endl;
    return 0;
}

2、面试题2

new 关键字创建出来的对象位于什么地方？一定只是在堆空间上吗？

  • 被忽略的事实
    — new/delete 的本质是C++预定义操作符（那么就可以进行操作符重载）
    — C++ 对这两个操作符做了严格的行为定义
  • new
    1、获取足够大的内存空间（默认为堆空间）
    2、在获取的空间中调用构造函数创建对象
  • delete
    1、调用析构函数销毁对象
    2、归还对象所占用的空间（默认为堆空间）
  • 在C++中能够重载new/delete操作符
    — 全局重载（不推荐）
    — 局部重载（针对具体类进行重载）
    重载 new/delete 的意义在于改变动态对象创建时的内存分配方式
  • new/delete 的重载方式
    在这里插入图片描述
    这两个重载的函数默认都是静态成员函数，无论你加不加static，它都是静态的。

全局数据区和栈的数据分布不一样。栈是向下生长，下一个地址值比上一个地址值小；全局数据区向上，下一个地址值比上一个地址值大。

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

class Test
{
	static const unsigned int COUNT = 4;
	static char c_buf[];
	static char c_map[];

public:
	void* operator new(unsigned int size)
	{
		void* ret = NULL;
		for (int i = 0; i < COUNT; i++)
		{
			if (!c_map[i])
			{
				c_map[i] = 1;
				ret = c_buf + i*sizeof(Test);
				cout << "succeed to allocate memory: " << ret << endl;
				break;
			}
		}
		return ret;
	}
	void operator delete(void* p)
	{
		char* mem = reinterpret_cast<char*>(p);
		int index = (mem - c_buf) / sizeof(Test);
		int flag = (mem - c_buf) % sizeof(Test);
		if ((flag == 0) && (index >= 0) && (index < COUNT))
		{
			c_map[index] = 0;
			cout << "succeed to free memory: " << p << endl;
			//遇到的问题：直接打印mem为什么打印不出来，因为char* 在cout 下会从该地址打印字符串，如果是输出指针的地址统一转换成 void*是最好的。
		}
	}
};

char Test::c_buf[sizeof(Test) * Test::COUNT] = {0};
char Test::c_map[COUNT] = {0};

int main()
{
	cout << "===== Test Object Array =====" << endl;

	Test* pt = new Test;

	delete pt;

	cout << "===== Test Object Array =====" << endl;

	Test* pa[5] = { 0 };

	for (int i = 0; i < 5; i++)
	{
		pa[i] = new Test;
		cout << "pa[" << i << "] = " << pa[i] << endl;
	}

	for (int i = 0; i < 5; i++)
	{
		cout << "delete " << pa[i] << endl;
		delete pa[i];
	}

	return 0;
}

在这里插入图片描述
这个程序告诉我们new出来的对象不一定是在堆空间上，在上面这个程序，new出来的对象就是在c_buf这个静态数组里面。

其实这个程序我一开始理解起来是非常困难的，还好我大哥一直在指点我。我不理解的地方主要是不知道为什么要定义c_map，c_map的本质就是作为标记使用。c_buf的本质就是存储内存空间。重载的new这个重载函数的 void 指针指向c_buf的首地址。c_map如果存满了，那么c_buf肯定就存满了，那么这个标志可以让c_buf不存储了。

重载的delete这个重载函数，因为c_buf里面共有 COUNT * sizeof(Test)个元素，所以在计算个数index 的时候要除以 sizeof(Test)，判断他在 new 第几个对象。delete完成的标志就是把 c_map这个标志设置为 0。

这个方法 + 二阶构造 = n例模式，使得我们最多只能存在n个对象。

3、面试题3

如何在指定的地址上创建 C++ 对象？

  • 解决方案
    — 在类中重载 new/delete操作符
    — 在 new的操作符重载函数中返回指定的地址
    — 在delete操作符重载中标记对于的地址可用

程序：在栈上动态创建对象

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

class Test
{
	static unsigned int c_count;
	static char* c_buf;
	static char* c_map;

	int m_value;
public:
	static bool SetMemorySource(char* memory, unsigned int size)
	{
		bool ret = false;
		c_count = size / sizeof(Test);
		ret = (c_count  && (c_map = reinterpret_cast<char*>(calloc(c_count, sizeof(char)))));
		if (ret)
		{
			c_buf = memory;
		}
		else
		{
			free(c_map);

			c_map = NULL;
			c_buf = NULL;
			c_count = 0;
		}
		return ret;
	}

	void* operator new(unsigned int size)
	{
		void* ret = NULL;
		if (c_count > 0)
		{
			for (int i = 0; i < c_count; i++)
			{
				if (!c_map[i])
				{
					c_map[i] = 1;
					ret = c_buf + i*sizeof(Test);
					cout << "succeed to allocate memory: " << ret << endl;
					break;
				}
			}
		}
		else
		{
			ret = malloc(size);
		}
		return ret;
	}
	void operator delete(void* p)
	{
		if (c_count > 0)
		{
			if (p != NULL)
			{
				char* mem = reinterpret_cast<char*>(p);
				int index = (mem - c_buf) / sizeof(Test);
				int flag = (mem - c_buf) % sizeof(Test);
				if ((flag == 0) && (index >= 0) && (index < c_count))
				{
					c_map[index] = 0;
					cout << "succeed to free memory: " << p << endl;
				}
			}
		}
		else
		{
			free(p);
		}
	}

};

unsigned int Test::c_count = 0;
char* Test::c_buf = NULL;
char* Test::c_map = NULL;

int main()
{
	char buffer[12] = { 0 };

	Test::SetMemorySource(buffer, sizeof(buffer));

	cout << "===== Test Object Array =====" << endl;

	Test* pt = new Test;

	delete pt;

	cout << "===== Test Object Array =====" << endl;

	Test* pa[5] = { 0 };

	for (int i = 0; i < 5; i++)
	{
		pa[i] = new Test;
		cout << "pa[" << i << "] = " << pa[i] << endl;
	}

	for (int i = 0; i < 5; i++)
	{
		cout << "delete " << pa[i] << endl;
		delete pa[i];
	}

	return 0;
}

在这里插入图片描述
解析：这个程序也很经典，可以使动态空间在栈上创建。并且限定个数。
主要有两点：
1、 SetMemorySource(char* memory, unsigned int size)这个函数使得 c_buf 和 c_map 重新有了作用。c_map的本质就是作为标记使用，c_buf的本质就是存储内存空间。c_map这个指针是指向我们 realloc 的一段空间，c_buf这个指针是指向我们指定的空间，c_buf指向的空间大于等于c_map指向的空间，之间的大小差距小于或等于一个类类型的大小。本质等同于上一段程序。
如果我们没有指定内存，就按默认的在堆上创建空间。

2、new 和 delete 的重载。

4、被忽略的事实4

  • new[]/delete[] 与 new/delete完全不同
    — 动态数组创建通过 new[] 完成
    — 动态数组的销毁通过 delete[] 完成
    — new/delete能够被重载，进而改变内存管理方式
  • new/delete的重载方式
    在这里插入图片描述
  • 注意事项
    — new[]实际需要返回的内存空间肯比期望的要多
    — 对象数组占用的内存中需要保存数组信息
    — 数组信息用于确定构造函数和析构函数的调用次数
#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;

class Test
{
	int m_value;
public:
	Test(int value = 0)
	{
		m_value = value;
	}

	~Test()
	{

	}

	void* operator new(unsigned int size)
	{
		cout << "operator new: " << size << endl;
		return malloc(size);
	}

	void operator delete(void* p)
	{
		cout << "operator delete: " << p << endl;
		free(p);
	}

	void* operator new[](unsigned int size)
	{
		cout << "operator new[]: " << size << endl;
		return malloc(size);
	}

		void operator delete[](void* p)
	{
		cout << "operator delete[]: " << p << endl;
		free(p);
	}

};


int main()
{
	Test* pt = new Test(1);
	delete pt;

	Test* pa = new Test[5];
	delete[] pa;
	return 0;
}

在这里插入图片描述
4*5 = 20，按理说是20个字节，系统多给4个字节保存长度信息。所以new[] 的空间只能delete[] ，如果delete并不能释放完全。

小结：

  • new/delete 的本质为操作符
  • 可以通过全局函数重载 new/delete
  • 可以针对具体的类重载 new/delete
  • new[]/delete[]与 new/delete完全不同
  • new[]/delete[]也是可以被重载的操作符
  • new[]返回的内存空间可能比期望的要多
xiebs_
关注
专栏目录
该项目采用C语言编写，模拟操作系统的内存管理，以及各种数据结构的自定义及使用.zip
01-20
管理系统是一种通过计算机技术实现的用于组织、监控和控制各种活动的软件系统。这些系统通常被设计用来提高效率、减少错误、加强安全性，同时提供数据和信息支持。以下是一些常见类型的管理系统： 学校管理系统： ...
C++解析(31)：自定义内存管理（完）
weixin_30535843的博客
12-10 475
0.目录 1.遗失的关键字mutable 2.new / delete 3.new[] / delete[] 4.小结 5.C++语言学习总结 1.遗失的关键字mutable 笔试题： 统计对象中某个成员变量的访问次数 遗失的关键字： mutable是为了突破const函数的限制而设计的 mutable成员变量将永远处于可改变的状态 mutable在实际的项目开发中被严禁滥用 mutable的...
C++语言学习（二十）——自定义内存管理
weixin_34150503的博客
08-27 134
C++语言学习（二十）——自定义内存管理 一、统计类对象中成员变量的访问次数 mutable是为了突破const函数的限制而设计的，mutable修饰的成员变量将永远处于可改变的状态。mutable成员变量破坏了只读对象的内部状态，而const成员函数保证只读对象的状态不变性，因此mutable成员变量无法保证只读对象状态的不变性。 #include <iostream> using...
C/C++内存管理
2301_77412625的博客
05-18 149
c/c++内存管理
用C语言手写动态内存管理
最新发布
zhuzhu的博客
07-26 698
设计一个动态内存管理的数据结构，用于管理整个内存池，包括Used、Free内存块的链表头储存，已经使用内存大小的储存等信息。该动态内存管理支持多段内存同时管理、内存合并、最佳匹配申请、内存申请记录、内存溢出检测等功能。
netty-netty-4.1.69.Final.tar.gz
10-20
2. **高效性**：Netty通过减少对象创建和内存复制来优化性能，例如，它的ByteBuf类提供了高效的字节缓冲区管理。 3. **灵活性**：Netty支持多种网络协议，如TCP、UDP、HTTP、WebSocket、FTP等，以及自定义协议。它...
Android 自定义加解密播放音视频（m3u8独立加密）伴随源码
09-17
6. **性能优化**：由于加密和解密操作会消耗计算资源，因此在实现时需要考虑性能优化，如使用硬件加速解密库，减少内存拷贝，以及合理调度任务以避免阻塞UI线程。 通过以上步骤，我们可以创建一个安全的、自定义加...
实现一个网络磁盘服务器，支持用户管理，分享文件，自定义文件传输协议，支持网页版和app版，2020毕业设计 .zip
01-17
高级语言： Python是一种高级编程语言，提供了自动内存管理（垃圾回收）等功能，减轻了程序员的负担，同时具有动态类型和面向对象的特性。 跨平台性： Python具有很好的跨平台性，可以在多个操作系统上运行，包括...
自己写的一个内存管理pool
07-31
重载new运算符重载new运算符重载new运算符重载new运算符重载new运算符重载new运算符重载new运算符重载new运算符
SDLOpenGLBaseC:杂乱的SDL OpenGL游戏引擎，否则用C从头开始编写。实现自定义内存管理系统。 支持基于约束的物理模拟和骨骼动画
03-22
我目前正在使用的非常精简的OpenGL / SDL应用程序框架版本，但使用C语言编写。代码非常凌乱，在将某些内容转储到GitHub之前已对其进行了一些修改。 我推送到GitHub的更新可能很少而且相去甚远。 当前功能列表： 在底层系统调用之上实现的完全自定义内存管理系统。 高效的刚体物理引擎，支持各种类型的对撞机和约束，以及用于岛屿的空间划分系统。 完整的动画系统，支持插值的骨骼动画和动画纹理。 功能齐全的命令系统，类似于Quake或Source引擎。 动态的可编程粒子系统。 自定义字体格式和快速渲染，同时支持BMP和MSDF（多通道带符号距离字段）。 基于OpenType字体规范，因此从TTF进行转换很简单。 支持各种对象的GUI系统。 支持2维，3维和4维向量和平方矩阵以及四元数的自定义数学库。 还支持各种几何运算。 按优先级（或实际上，从最简单或最有趣的内容到更烦
内存管理模型的设计与实现(操作系统)
07-12
对内存的可变分区申请采用链表法管理进行模拟实现。要求： （1） 对于给定的一个存储空间自己设计数据结构进行管理，可以使用单个链表，也可以使用多个链表，自己负责存储空间的所有管理组织，要求采用分页方式（指定单元大小为页，如4K，2K，进程申请以页为单位）来组织基本内容； （2） 当进程对内存进行空间申请操作时，模型采用一定的策略（如：首先利用可用的内存进行分配，如果空间不够时，进行内存紧缩或其他方案进行处理）对进程给予指定的内存分配； （3） 从系统开始启动到多个进程参与申请和运行时，进程最少要有3个以上，每个执行申请的时候都要能够对系统当前的内存情况进行查看的接口； （4） 对内存的申请进行内存分配，对使用过的空间进行回收，对给定的某种页面调度进行合理的页面分配。 （5） 利用不同的颜色代表不同的进程对内存的占用情况，动态更新这些信息。
四、内存管理
西西弗的博客
08-19 184
FreeRTOS自己实现内存管理的必要性，FreeRTOS中的5种内存管理方法，Heap相关的函数。
自己写的STM32 内存管理 实现了malloc,free,remalloc等函数
--------→成人不自在，自在不成人℃ ------------
08-12 3889
这两天写的一个STM32上的内存管理函数,实现了malloc和free以及remalloc几个函数.还实现了一个内存使用率查询的函数. 实验环境：ALIENTEK STM32 Mini 开发板 思路如下: 将内存分块管理. 内存池等分为固定大小的内存块. 建立一个内
为单片机编写一个简易的动态内存管理库（参考RT-Thread的小内存分配算法）
weixin_43095720的博客
05-18 1040
编写一个简易的单片机动态内存管理库
技巧：自定义内存管理
weixin_46258483的博客
09-17 128
const成员函数内部不能修改成员变量！！！ 这个关键字在工程中用的比较少 #include <iostream> #include <string> using namespace std; class Test { int m_value; int * const m_pCount;//指针为常量，不能被改变，但是指向的值可以！ /* mutable int m_count; */ public: Test(int value = 0) .
实现简单的内存管理
qq_32938605的博客
07-13 742
1 源码： 源码已经提交github，内存管理github链接，欢迎一起讨论。 2 实现过程 该代码实现了在固定地址空间上进行内存的分配与释放。在操作系统启动时刻指定固定的地址作为mymlloc（）操作的Heap空间，也可以直接定义数组。在嵌入式系统中，最好指定固定的地址，方便进行管理以及问题的排查。 2.1 内存控制块定义 struct free_block_t{ unsigned long size; unsigned char *start; unsigned char *en
自己动手写的内存管理程序
cassper的专栏
06-12 788
/*** 自己动手写的内存管理程序* 完善中* chenbdchenbd@gmail.com**/#include #include #include #define MM_OK (0x00)#define MM_NG (0xff)#define MM_UNIT ((uns
C语言开发模拟操作系统内存管理与数据结构应用
资源摘要信息:"该项目的核心内容是使用C语言编写一个模拟操作系统内存管理的程序，并在其中自定义及使用各种数据结构。该程序的开发是一个重要的学习案例，适用于计算机科学和软件工程课程设计。项目不仅覆盖了C语言...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值