mutable是为了突破const函数的限制而设计的，mutable修饰的成员变量将永远处于可改变的状态。mutable成员变量破坏了只读对象的内部状态，而const成员函数保证只读对象的状态不变性，因此mutable成员变量无法保证只读对象状态的不变性。
网站建设哪家好，找成都创新互联公司！专注于网页设计、网站建设、微信开发、微信平台小程序开发、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了云南免费建站欢迎大家使用！
重庆分公司
重庆分公司
#include
using namespace std;
class Test
{
public:
Test():m_count(0)
{
}
void setValue(const int value)
{
m_count++;
m_data = value;
}
int getValue()
{
m_count++;
return m_data;
}
int getValue()const
{
m_count++;
return m_data;
}
int getCount()const
{
return m_count;
}
private:
int m_data;
mutable int m_count;
};
int main(int argc, char *argv[])
{
Test test1;
test1.setValue(100);
cout << test1.getCount() << endl;
const Test test2;
test2.getValue();
cout << test2.getCount() << endl;
return 0;
} 上述代码使用mutable修饰成员变量m_count，确保在const函数内部也可以改变其值，但mutable破坏了只读对象状态的不变性，所以不推荐。
#include
using namespace std;
class Test
{
public:
Test():m_count(new int(0))
{
}
void setValue(const int value)
{
*m_count = *m_count + 1;
m_data = value;
}
int getValue()
{
*m_count = *m_count + 1;
return m_data;
}
int getValue()const
{
*m_count = *m_count + 1;
return m_data;
}
int getCount()const
{
return *m_count;
}
private:
int m_data;
int* const m_count;
};
int main(int argc, char *argv[])
{
Test test1;
test1.setValue(100);
cout << test1.getCount() << endl;
const Test test2;
test2.getValue();
cout << test2.getCount() << endl;
return 0;
} 上述代码使用指针常量统计访问成员变量的次数，不会破坏只读对象的状态不变性。
new/delete的本质是C++预定义的操作符，C++语言规范对new/delete操作符做出了严格的规范：
A、new关键字用于获取足够的内存空间（默认为堆空间），在获取的空间中调用构造函数创建对象。
B、delete调用析构函数销毁对象，归还对象所占用的空间（默认为堆空间）。
C++语言中可以重载new/delete操作符，重载new/delete操作符的意义在于改变动态对象创建时的内存分配方式，可以将new创建的对象分配在栈空间、静态存储空间、指定地址空间。
new/delete操作符支持全局重载、局部重载，但不推荐对new/delete操作符进行全局重载，通常对new/delete操作符进行局部重载，如针对具体的类进行new/delete操作符重载。
new/delete操作符重载函数默认为静态函数，无论是否显示声明static关键字。
//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 */
}#include
using namespace std;
class Test
{
private:
static const unsigned int COUNT = 4;
static char c_buffer[];
static char c_map[];
int m_value;
public:
Test(int value = 0)
{
m_value = value;
cout << "value : " << value << endl;
}
//static member function
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_buffer + i * sizeof(Test);
cout << "succeed to allocate memory: " << ret << endl;
break;
}
}
return ret;
}
//static member function
void operator delete (void* p)
{
if( p != NULL )
{
char* mem = reinterpret_cast(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;
}
}
}
int getValue()const
{
return m_value;
}
};
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(1);
delete pt;
cout << "===== Test Object Array =====" << endl;
Test* pa[5] = {0};
for(int i=0; i<5; i++)
{
pa[i] = new Test(100 + i);
cout << "pa[" << i << "] = " << pa[i] << endl;
}
for(int i=0; i<5; i++)
{
cout << "delete " << pa[i] << endl;
if(pa[i] != NULL)
{
delete pa[i];
}
}
return 0;
} 上述代码，new会创建Test对象到静态存储空间中，从打印结果可以知道new创建Test对象时先调用new操作符重载函数，在返回的空间中再调用Test构造函数。
在类中对new/delete操作符进行重载，在new操作符重载函数中返回指定的地址，在delete操作符重载函数中标记对应的地址可用。
#include
#include
#include
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(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 0 )
{
char* mem = reinterpret_cast(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;
} 上述代码中，可以在指定地址空间创建对象，也可以不指定地址空间，此时在堆空间创建对象。
#include
using namespace std;
class Test
{
int m_value;
public:
Test(int value = 0)
{
m_value = value;
cout << "value : " << m_value << endl;
cout << "this : " << this << endl;
}
};
int main(int argc, char *argv[])
{
Test test(100);
//在栈空间创建对象
Test* pTest = new(&test) Test(1000);
return 0;
}
上述代码中，可以使用new操作符的默认实现在栈空间创建对象。 new[]/delete[]关键字与new/delete关键字完全不同，是一组全新的关键字。
new[]关键字用于创建动态对象数组，delete[]关键字用于销毁动态对象数组。new[]/delete[]关键字可以进行重载，用于优化内存管理方式。new[]关键字返回的空间大小通常大于预期的动态数组空间大小。
#include
#include
#include
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(int argc, char *argv[])
{
Test* pt = NULL;
pt = new Test;
delete pt;
pt = new Test[5];
delete[] pt;
return 0;
} 上述代码中，重载了new[]/delete[]关键字。
