記憶體分配和釋放
STL中有兩個分配器，一級分配器和二級分配器，預設使用二級分配器，使用二級分配器分配大記憶體時會呼叫一級分配器去執行，一級分配器使用malloc和free分配和釋放記憶體。如果分配小記憶體那麼二級分配器會從記憶體池中進行查詢，防止malloc/free的開銷。
為了瞭解原理，不深挖細節，只實現一級分配器也是可以的：
class first_level_alloc {
public:
static void* allocate(size_t n) {
void* result = malloc(n); //直接使用malloc
//todo: out of memory handler
return result;
}
static void deallocate(void* p, size_t) {
free(p); //直接使用free
}
};一級分配器，直接呼叫malloc和free分配和釋放記憶體。這裡也沒有處理分配失敗的情況。
為了方便使用定義一個包裝類：
template <typename T, typename Alloc>
class simple_alloc {
public:
static T* allocate(size_t n) {
return (0 == n) ? nullptr : static_cast<T *>(Alloc::allocate(n * sizeof(T)));
}
static T* allocate() {
return static_cast<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));
}
};對外使用這個包裝類别範本引數T指定要分配的物件型別，Alloc指定分配器，因為沒有實現二級分配器，所以都是指定為一級分配器first_level_alloc。
物件的構造和析構
定義如下三個函式：
template <typename T>
inline void construct(T* p, const T& value) {
new(p) T(value); //placement new
}
template <typename T>
inline void destroy(T *p) {
p->~T();
}
//todo:low efficiency
template <typename ForwardIterator>
inline void destroy(ForwardIterator first, ForwardIterator last) {
for (; first != last; ++first) {
destroy(&*first);
}
}void construct(T* p, const T& value)：在p指向的位置用value拷貝構造T物件並返回。這裡用到了placement new。void destroy(T *p)：析構p指向處的T物件。void destroy(ForwardIterator first, ForwardIterator last)：析構[first, last)區間的物件。這裡沒有考慮效率，直接使用for迴圈呼叫destroy。STL庫中使用模板特例化，根據迭代器指向的型別有沒有trivial destructor，執行不同的特例化版本。如果有trivial destructor，比如內建型別，那麼什麼也不用做。如果有non-trivial destructor才呼叫上述的那個版本。
traits要解決的問題
假如演算法中要宣告“迭代器所指類別”的變數，該怎麼辦？
內嵌類別宣告解決非指標迭代器的情況
template <typename T>
struct MyIter { //模擬迭代器型別
typedef T value_type; //內嵌類別宣告
T* ptr;
MyIter(T* p = 0) :ptr(p) {}
T& operator*() const {
return *ptr;
}
};
template <typename I>
typename I::value_type //返回型別為迭代器指向的型別
func(I ite) { //該函式傳入一個指標，返回指標指向的值。
return *ite;
}
int main() {
MyIter<int> ite(new int(8));
cout << func(ite);
}MyIter模擬迭代器，T是迭代器所指的型別，通過在迭代器內typedef T value_type;後，就能用MyIter
上面的方法解決了一部分問題，但是普通指標也是迭代器型別，我們沒辦法給指標應用上面的方法。比如上面的func，如果我們傳入一個指標，肯定無法通過編譯。
使用模板特例化解決普通指標的情況
template <typename T>
struct MyIter {
typedef T value_type;
T* ptr;
MyIter(T* p = 0) :ptr(p) {}
T& operator*() const {
return *ptr;
}
};
template <typename I>
struct iterator_traits { //針對普通迭代器的模板類
typedef typename I::value_type value_type;
};
template <typename I>
struct iterator_traits<I*> { //針對指標型別的模板特例化
typedef I value_type;
};
template <typename I>
typename iterator_traits<I>::value_type
func(I ite) { //該函式返回迭代器或這種指向的值
return *ite;
}
int main() {
MyIter<int> it(new int(8));
int* ip = new int(8);
std::cout << func(ip) << std::endl;
std::cout << func(it);
}這裡定義了一個模板類iterator_traits，實際使用時iterator_traits<I>::value_type就是迭代器I所指的型別，如果是迭代器是指標型別，那麼匹配的是itetraor_traits的特例化，iterator_traits<I>::value_type依然可以得到指標所指型別。
所以所謂的traits就是一個模板類和一系列模板特例化。通過這個模板類可以得到指標或者迭代器的相關型別。
同時如果一個迭代器型別如果想要和traits類配合使用需要在其內部通過typedef定義value_type型別。
迭代器相應類別
前面的迭代器所指型別value_type就是迭代器的相關類別之一，除了迭代器所指型別，還有幾個迭代器相關型別。
- value_type：迭代器所指型別，上一節已經講過了。
- difference type：用來表示兩個迭代器之間的距離。
- reference type：迭代器所指型別的引用型別。
- pointer type：迭代器所指型別的指標型別。
- iterator_category：迭代器的類別。