版权声明:本文为博主原创文章,转载请注明出处! https://blog.csdn.net/qq_27513221/article/details/79822453
第69课 技巧:自定义内存管理
一、笔试题
统计对象中某个成员变量的访问次数
编程实验:成员变量的访问统计
实现方法一:使用mutable
#include<iostream>
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_count++;
m_value = value;
}
int getCount() const{
return m_count;
}
~Test(){
}
};
int main(){
Test t;
t.setValue(100);
cout << "t.m_value = " << t.getValue() << endl;
cout << "t.m_count = " << t.getCount() << endl;
const Test ct(200);
cout << "ct.m_value = " << ct.getValue() << endl;
cout << "ct.m_count = " << ct.getCount() << endl;
return 0;
}
打印结果:
t.m_value = 100
t.m_count = 2
ct.m_value = 200
ct.m_count = 1
遗失的关键字:
mutable
是为了突破const
函数的限制而设计的mutable
成员变量将永远处于可改变的状态mutable
在实际的项目开发中被严禁滥用
mutable
的深入分析:
mutable
成员变量破坏了只读对象的内部状态const
成员函数保证只读对象的状态不变性mutable
成员变量的出现无法保证状态不变性
实现方法二:使用指针
#include<iostream>
using namespace std;
class Test{
int m_value;
int * const m_pCount;
public:
Test(int value = 0) : m_pCount(new int(0)){
m_value = value;
}
int getValue() const{
*m_pCount += 1;
return m_value;
}
void setValue(int value){
*m_pCount += 1;
m_value = value;
}
int getCount() const{
return *m_pCount;
}
~Test(){
delete m_pCount; //注意不要忘了释放指针
}
};
int main(int argc,char * argv[]){
Test t;
t.setValue(100);
cout << "t.m_value = " << t.getValue() << endl;
cout << "t.m_count = " << t.getCount() << endl;
const Test ct(200);
cout << "ct.m_value = " << ct.getValue() << endl;
cout << "ct.m_count = " << ct.getCount() << endl;
return 0;
}
打印结果相同。通过使用指针进行变量的修改
二、面试题二
new
关键字创建出来的对象位于什么地方?
new/delete
的本质是C++预定义的操作符C++对这两个操作符做了严格的行为定义
new
:-
- 获取足够大的内存空间(默认为堆空间)
- 在获取的空间中调用构造函数创建对象
delete
-
- 调用析构函数销毁对象
- 归还对象所占用的空间(默认为堆空间)
在C++中能够重载new/delete
操作符
- 全局重载(不推荐)
- 局部重载(针对具体类进行重载)
重载new/delete
的意义在于改变动态对象创建时的内存分配方式
new/delete
的重载方式
//static member function
void* operator new (unsigned int size){
void* ret = NULL;
/* ret point to allocated memory */
return ret;
}
//static member function
void operator delete (void* p){
/* free the memory which is pointed by p */s
}
编程实验:静态存储区中创建动态对象
#include<iostream>
using namespace std;
class Test{
static const unsigned int COUNT= 4;
static char c_buffer[];//将空间放置在静态存储区
static char c_map[];
int m_value;
public:
void* operator new (unsigned int size){//new重载
void* ret = NULL;
for(int i = 0;i < COUNT;++i){
if(!c_map[i]){
c_map[i] = 1;
ret = c_buffer + i * sizeof(Test);//指针加法
cout << "succeed to allocate memory:" << ret << endl;
break;
}
}
return ret;
}
void operator delete (void* p){ //delete重载
if(p != NULL){
char* mem = reinterpret_cast<char*>(p);
int index = (mem - c_buffer) / sizeof(Test);
int flag = (mem - c_buffer) % sizeof(Test);
if((flag == 0) && (0 <= index) && (index < COUNT)){
c_map[index] = 0;
cout << "succeed to free memory:" << p << endl;
}
}
}
};
char Test::c_buffer[sizeof(Test) * Test::COUNT] = {0};
char Test::c_map[Test::COUNT] = {0};
int main(int argc,char *argv[]){
cout << "========= Test Single Object =========" << 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;
}
打印结果:
===== Test Single Object =====
succeed to allocate memory: 0x6021a0
succeed to free memory: 0x6021a0
===== Test Object Array =====
succeed to allocate memory: 0x6021a0
pa[0] = 0x6021a0
succeed to allocate memory: 0x6021a4
pa[1] = 0x6021a4
succeed to allocate memory: 0x6021a8
pa[2] = 0x6021a8
succeed to allocate memory: 0x6021ac
pa[3] = 0x6021ac
pa[4] = 0
delete 0x6021a0
succeed to free memory: 0x6021a0
delete 0x6021a4
succeed to free memory: 0x6021a4
delete 0x6021a8
succeed to free memory: 0x6021a8
delete 0x6021ac
succeed to free memory: 0x6021ac
delete 0
三、面试题三
如何在指定的地址上创建C++对象?
解决方案:
- 在类中重载
new/delete
操作符 - 在
new
的操作符重载函数中返回指定的地址 - 在
delete
操作符重载中标记对应的地址可用
编程实验:自定义动态对象的存储空间
#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
class Test
{
static unsigned int c_count;
static char* c_buffer;
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_buffer = memory;
}
else
{
free(c_map);
c_map = NULL;
c_buffer = 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_buffer + i * sizeof(Test);
cout << "succeed to allocate memory: " << ret << endl;
break;
}
}
}
else
{
ret = malloc(size);
}
return ret;
}
void operator delete (void* p)
{
if( p != NULL )
{
if( c_count > 0 )
{
char* mem = reinterpret_cast<char*>(p);
int index = (mem - c_buffer) / sizeof(Test);
int flag = (mem - c_buffer) % sizeof(Test);
if( (flag == 0) && (0 <= index) && (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_buffer = NULL;
char* Test::c_map = NULL;
int main(int argc, char *argv[])
{
char buffer[12] = {0};
Test::SetMemorySource(buffer, sizeof(buffer));
cout << "===== Test Single Object =====" << 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;
}
打印结果
===== Test Single Object =====
succeed to allocate memory: 0x7ffff9dabb90
succeed to free memory: 0x7ffff9dabb90
===== Test Object Array =====
succeed to allocate memory: 0x7ffff9dabb90
pa[0] = 0x7ffff9dabb90
succeed to allocate memory: 0x7ffff9dabb94
pa[1] = 0x7ffff9dabb94
succeed to allocate memory: 0x7ffff9dabb98
pa[2] = 0x7ffff9dabb98
pa[3] = 0
pa[4] = 0
delete 0x7ffff9dabb90
succeed to free memory: 0x7ffff9dabb90
delete 0x7ffff9dabb94
succeed to free memory: 0x7ffff9dabb94
delete 0x7ffff9dabb98
succeed to free memory: 0x7ffff9dabb98
delete 0
delete 0
四、被忽略的事实
new[] / delete[]
与 new /delete
完全不同
- 动态对象数组创建通过new[] 完成
- 动态对象数组的销毁通过delete[]完成
- new[] / delete[] 能够被重载,进而改变内存管理方式
new[] / delete[] 的重载方式
//static member function
void* operator new[] (unsigned int size){
return malloc(size);
}
//static member function
void operator delete[] (void* p){
free(p);
}
注意事项:
- new[]实际需要返回的内存空间可能比期望的要多
- 对象数组占用的内存中需要保存数组信息 (比期望多的部分)
- 数组信息用于确定构造函数和析构函数的调用次数
编程实验:动态数组的内存管理
#include <iostream>
#include <string>
#include <cstdlib>
using namespace std;
class Test
{
int m_value;
public:
Test()
{
m_value = 0;
}
~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(int argc, char *argv[])
{
Test* pt = NULL;
//都是成对出现的,不能交错,因为二者使用的地址可能不相同
pt = new Test;
delete pt;
pt = new Test[5];
delete[] pt;
return 0;
}
打印结果:
operator new: 4
operator delete: 0x2111e30
operator new[]: 28
operator delete[]: 0x2111e50
五、总结
new/delete
的本质为操作符- 可以通过全局函数重载
new /delete
(不推荐) - 可以针对具体的类重载
new /delete
new[] / delete[]
与new /delete
完全不同new[] / delete[]
也是可以被重载的操作符new[]
返回的内存空间可能比期望的要多