【more effective c++读书笔记】【第5章】技术(3)——要求(或禁止)对象产生于heap之中
一、要求对象产生于heap之中
方法:让析构函数成为private,构造函数为public。然后导入一个伪的析构函数,来调用真正的析构函数。但是它也妨碍了继承和内含。
例子:
//UPNumber.h #ifndef UPNUMBER_H #define UPNUMBER_H #include<iostream> class UPNumber{ public: UPNumber() :value(0) { std::cout << "UPNumber()" << std::endl; } UPNumber(int initValue) :value(initValue) { std::cout << "UPNumber(int initValue)" << std::endl; } UPNumber(const UPNumber& rhs) { this->value = rhs.value; } //伪构造函数 void destroy() const { delete this; } private: ~UPNumber() { std::cout << "~UPNumber()" << std::endl; } int value; }; #endif //main.cpp #include "UPNumber.h" using namespace std; int main(){ //UPNumber n;//错误,析构函数是private的 UPNumber* p = new UPNumber; //delete p;//错误,析构函数是private的 p->destroy(); system("pause"); return 0; }
另一个方法就是将所有的构造函数都声明为private。这个方法的缺点是类常常有多个构造函数,类的作者必须将它们每一个都声明为private。所以比较容易的方法还是让析构函数成为private,构造函数为public,因为一个类只有一个析构函数。
上述方法说到妨碍了继承,可以用如下方法解决:令UPNumber的析构函数成为protected。也说到妨碍了内含UPNumber对象,可以用如下方法解决:内含一个UPNumber类的指针,指向UPNumber对象。
二、禁止对象产生于heap之中
方法:直接将对象产生于heap之中,总是以new产生出来的。new operator总是调用operator new,可以将operator new声明为private。
例子:
//UPNumber.h #ifndef UPNUMBER_H #define UPNUMBER_H #include<iostream> class UPNumber{ public: UPNumber() :value(0) { std::cout << "UPNumber()" << std::endl; } UPNumber(int initValue) :value(initValue) { std::cout << "UPNumber(int initValue)" << std::endl; } UPNumber(const UPNumber& rhs) { this->value = rhs.value; } ~UPNumber() { std::cout << "~UPNumber()" << std::endl; } private: static void* operator new(size_t size); //禁止UPNumber对象位于heap内 static void* operator new[](size_t size) ;//禁止UPNumber对象组成的数组位于heap内 static void operator delete(void* ptr); //禁止UPNumber对象位于heap内 static void operator delete[](void* ptr); //禁止UPNumber对象组成的数组位于heap内 int value; }; #endif //main.cpp #include "UPNumber.h" using namespace std; int main(){ UPNumber n1;//可以 static UPNumber n2;//也可以 //UPNumber* p = new UPNumber;//错误,operator new是private的 system("pause"); return 0; }
将operator new声明为private,往往也会妨碍UPNumber对象被实例化为heap-based继承类对象的基类成分。因为operator new和operator delete都会被继承,所以如果这些函数不在继承类内声明为public,继承类继承的便是基类声明的private版本。
当UPNumber作为其他类的内嵌对象,UPNumber的operator new为private没有什么影响。
三、判读某个对象是否位于heap内
方法有以下几种:
1、在类中增加静态变量指示是否调用operator new来分配内存;如果不是使用operator new来构造对象,就在构造函数中抛出异常。
例子:
//UPNumber.h #ifndef UPNUMBER_H #define UPNUMBER_H #include<iostream> class UPNumber{ public: class HeapConstrainViolation{}; static void* operator new(size_t size); UPNumber(); UPNumber(int initValue); UPNumber(const UPNumber& rhs); private: int value; static bool onTheHeap;//用来在构造函数内指示正构造中的对象是否位于heap }; bool UPNumber::onTheHeap = false; void* UPNumber::operator new(size_t size){ onTheHeap = true; return ::operator new(size); } UPNumber::UPNumber() :value(0) { if (!onTheHeap) throw HeapConstrainViolation(); std::cout << "UPNumber()" << std::endl; } UPNumber::UPNumber(int initValue) : value(initValue) { if (!onTheHeap) throw HeapConstrainViolation(); std::cout << "UPNumber(int initValue)" << std::endl; } UPNumber::UPNumber(const UPNumber& rhs) { this->value = rhs.value; } #endif //main.cpp #include "UPNumber.h" using namespace std; int main(){ //UPNumber n;//发生异常 UPNumber* p = new UPNumber; delete p; system("pause"); return 0; }
这种方法有以下几个问题:
a、考虑如下代码:
UPNumber* numberArray = new UPNumber[100];
出现第一个问题是数组由operator new[]分配,这个仍可以自己写一个operator new[]的版本。第二个问题numberArray有100个元素,应该有100次构造函数调用,但整个程序只有一次内存分配,所以在100次构造函数中,只有第一次onTheHeap的值为true,后面调用构造函数时有exception抛出。
b、考虑如下代码:
UPNumber* pn = new UPNumber(*new UPNumber);
我们通常希望函数调用顺序如下:
1)调用第一个对象的operator new
2)调用第一个对象的constructor
3)调用第二个对象的operator new
4)调用第二个对象的constructor
但C++不保证这么做,有可能是这样的顺序
1)调用第一个对象的operator new
2)调用第二个对象的operator new
3)调用第一个对象的constructor
4)调用第二个对象的constructor
因在步骤1)和2)中设立的onTheHeap的值在步骤3)中被清除了,造成步骤4)的对象认为它不处于heap之中。
2、根据stack和heap的增长方向来判断内存是否在heap中分配。
依据的事实是程序的地址空间以线性序列组织而成,其中栈从高地址往低地址生长,堆从低地址往高地址生长。这种方法存在两个问题,一是不具有可移植性;二是区分不了heap和static。
3、维护一个集合,operator new负责把对象的地址加入到一个由动态分配所形成的集合中,operator delete负责把该对象的地址移除,判断一个对象是否在heap中,就看这个对象的地址是否在集合中。对于全局的operator new和operator delete会有以下三个问题:第一,改变原有的operator new和operator delete的语义;第二,效率低,需要承担沉重的簿记工作;第三,当对象涉及多重继承或虚继承的基类时,会拥有多个地址。
4、采用抽象abstract mixin base class(抽象混合式基类)。
抽象基类是一个不能被实例化的基类,至少含有一个纯虚函数;混合类则提供一组定义完好的能力,能够与派生类所提供的其他任何功能兼容。我们可以形成一个抽象混合式基类,用来为继承类提供判读某指针是否以operator new分配出来的能力。
例子:
//HeapTracked.h #ifndef HEAPTRACKED_H #define HEAPTRACKED_H #include<list> #include<iostream> class HeapTracked{ public: class MissingAddress {};//异常类 virtual ~HeapTracked() = 0; static void* operator new(size_t size); static void operator delete(void* ptr); bool isOnHeap() const; private: static std::list<const void*> addresses; }; std::list<const void*> HeapTracked::addresses; HeapTracked::~HeapTracked() {} void* HeapTracked::operator new(size_t size){ void* memPtr = ::operator new(size);//取得内存 addresses.push_back(memPtr);//将其地址置于list内 return memPtr; } void HeapTracked::operator delete(void* ptr){ std::list<void const*>::iterator iter = find(addresses.begin(), addresses.end(), ptr); if (iter != addresses.end()){//如果找到符合条件的元素,移除之并释放内存 addresses.erase(iter); ::operator delete(ptr); } else{//否则表示ptr不是operator new所分配,抛出一个异常 throw MissingAddress(); } } bool HeapTracked::isOnHeap() const{ //取得一个指针,指向*this所占内存的起始处 const void* rawAddress = dynamic_cast<const void*>(this); std::list<const void*>::iterator iter = find(addresses.begin(), addresses.end(), rawAddress); return iter != addresses.end();//返回找到与否的消息 } #endif //main.cpp #include "HeapTracked.h" using namespace std; class Asset :public HeapTracked{ public: Asset(int initValue) {} }; int main(){ Asset s(10); if (s.isOnHeap()) cout << "is on heap" << endl; else cout << "is not on heap" << endl; Asset* p = new Asset(1); if (p->isOnHeap()) cout << "is on heap" << endl; else cout << "is not on heap" << endl; delete p; system("pause"); return 0; }
上述Heaptracked这样的mixin类有个缺点,就是不能够使用于内建类型身上,因为像int和char这种内建类型并不继承自任何东西。
版权声明:本文为博主原创文章,未经博主允许不得转载。
posted on 2015-09-04 14:47 ruan875417 阅读(167) 评论(0) 编辑 收藏 举报