【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这种内建类型并不继承自任何东西。

版权声明：本文为博主原创文章，未经博主允许不得转载。