stl1

如果你针对某个class进行operator()重载，它就成为一个仿函数。


template<class T, class Alloc = alloc> //可以指定默认"参数"


一般而言，我们所习惯的C++内存配置操作和释放操作是这样的：
class Foo{...};
Foo * pf = new Foo();
delete pf;
这其中的new算式内含两阶段操作：（1）调用::operator new 配置内存;（2）调用Foo::Foo()构造对象内容。delete算式也内含两阶段操作:（1）调用Foo::~Foo()将对象析构；（2）调用::operator delete释放内存。


template<class T1, class T2>
inline void construct(T1 * p, const T2 & value)
{
	new (p) T1(value);//placement new
}


template<class T, class Alloc>
class simple_alloc
{
public:
	static T* allocate(size_t n)
	{
		return 0 == n ? 0 : (T*)Alloc::allocate(n * sizeof(T));
	}
	static T* allocate(void)
	{
		return (T*)Alloc::allocate(sizeof(T));
	}
	static void deallocate(T* p, size_t n)
	{
		if(0 != n)
			Alloc::deallocate(p, n * sizeof(T));
	}
	static void deallocate(T* p)
	{
		Alloc::deallocate(p, sizeof(T));
	}
}
这个接口使配置器的配置单位从bytes转为个别元素的大小(sizeof(T))。


所谓C++ new handler机制是，你可以要求系统在内存配置需求无法被满足时，调用一个你所指定的函数。换句话说，一旦::operator new无法完成任务，在丢出std::bad_alloc异常状态之前，会先调用由客端指定的处理例程。该处理例程通常即被称为new-handler。


SGI第二级配置器的做法是，如果区块够大，超过128 bytes时，就移交第一级配置器处量。当区块小于128 bytes时，则以内存池(memory pool)管理。


ROUND_UP()将bytes上调至8的倍数
size_t ROUNT_UP(size_t bytes)
{
	return (((bytes) + __ALIGN - 1) & ~(__ALIGN - 1));
}


template<class I, class T>
void func_impl(I iter, T t)
{
	T tmp;
	//..
}
template<class I>
void func(I iter)
{
	func_impl(iter, *iter);
}
int main()
{
	int i;
	func(&i);
}


void func()
{
	auto_ptr<string> ps(new string("jjhou"));
	cout << *ps << endl;
	//离开前不需delete,auto_ptr会自动释放内存
}




假设有个算法可接受Forward Iterator,你以Random Access Iterator喂给它,它当然也会接受,因为一个Random Access Iterator必然是一个Forward Iterator.但是可用并不代表最佳。