STL-空間配置器、迭代器、traits編程技巧

目錄

• 內存分配和釋放
• 對象的構造和析構
• traits要解決的問題
  • 內嵌類別聲明解決非指針迭代器的狀況
  • 使用模板特例化解決普通指針的狀況
• 迭代器相應類別

內存分配和釋放

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);
    }
}

1. void construct(T* p, const T& value)：在p指向的位置用value拷貝構造T對象並返回。這裏用到了placement new。
2. void destroy(T *p)：析構p指向處的T對象。
3. 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 ::value_type定義T類型的變量。
上面的方法解決了一部分問題，可是普通指針也是迭代器類型，咱們沒辦法給指針應用上面的方法。好比上面的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就是迭代器的相關類別之一，除了迭代器所指類型，還有幾個迭代器相關類型。

1. value_type：迭代器所指類型，上一節已經講過了。
2. difference type：用來表示兩個迭代器之間的距離。
3. reference type：迭代器所指類型的引用類型。
4. pointer type：迭代器所指類型的指針類型。
5. iterator_category：迭代器的類別。