统计对象中某个成员变量的访问次数？
mutable是为了突破const函数的限制而设计的，mutable成员变量将永远处于可改变状态，mutable在实际的项目中被严禁滥用。
mutable深入分析：
mutable成员变量破坏了只读对象的内部状态，const成员函数保证只读对象的状态不改变，mutable成员变量的出现无法保证状态不变性。
#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)) //默认值：如果没有参数，默认为0
{
m_value = value;
/* m_count = 0; */
}
int getValue() const //const成员函数不能修改任何成员变量的值，只能调用只读对象
{/* m_count++; */
*m_pCount = *m_pCount + 1;
return m_value;
}
void setValue(int value)
{
/* m_count++; */
*m_pCount = *m_pCount + 1;
m_value = value;
}
int getCount() const
{
/* return m_count; */
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;
}
2、new关键字创建出来的对象位于什么地方？
new/delete的本质是c++预定义的操作符。
c++对这两个操作符做了严格的行为定义。
new：1、获取足够大的内存空间（默认为堆空间）2、在获取的空间中调用构造函数创建对象。
delete：1、调用析构函数销毁对象 2、归还对象所占用的空间（默认为堆空间）。
在c++中能重载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*/
}
*******************************************
#include <iostream>
#include <string>
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)
{
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)
{
if( p != NULL )
{
char* mem = reinterpret_cast<char*>(p);
int index = (mem - c_buffer) / sizeof(Test); //要释放的动态对象在 c_map标记数组中的位置
int flag = (mem - c_buffer) % sizeof(Test); //这些位置必须是固定的，如果不为0，指针不合法
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;
}
单例模式仅一个对象，这个方法加二阶构造就能创建N例模式了。
3、如何在指定的地址上创建c++对象？
解决方案：
在类中重载new/delete操作符，在new的操作符重载函数中返回指定的地址，在delete操作符重载中标记对应的地址可用。
#include <iostream>
#include <string>
#include <cstdlib> //calloc
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;
}
4、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]; //打印出24，多的四个字节用来保存数组大小信息
delete[] pt;
return 0;
}
new 和 new[] 内存分配方式可能不一样
new/delete的本质为操作符，可以通过全局函数重载new/delete(不推荐)，可以针对具体的类重载new/delete，new[]/delete[]与new/delete完全不同，new[]/delete[]也是可以被重载的操作符，new跟delete要成对出现。new[]返回的内存空间可能比期望的要多。