眾所周知，STL的容器類是針對對象來進行存儲管理的。雖然沒有明確的限制不能在STL的容
器類中包含指針，STL也不在乎您存放在容器中的對象還是指針。但仔細考慮STL的初衷，
在容器類中使用指針是明顯不合時宜的。
CKER的意思是您應(yīng)該盡可能的直接將對象本身而不是將對象的指針放置在STL容器類中。直接
在容器中存放指針一個最大的副作用就是可能導(dǎo)致內(nèi)存泄漏。這個問題在char *類型上有突出
的體現(xiàn)。
但某些時候，直接使用對象指針有明顯的好處，這些情況大致可以概括為如下的幾個方面：
1. 當對象十分龐大時，頻繁的拷貝復(fù)制所帶來的系統(tǒng)資源消耗十分昂貴。
2. 當您需要將同一個對象存放到多個容器中，這種情況應(yīng)該不是很少見的。
3. 當您需要在同一個容器中存放由同一個父類派生而來的多個派生類對象。這也很常見。
事實上，CKER這個星期所開發(fā)的計算程序中，正需要面對第三種情況�？紤]使用STL的種種好處。
CKER決定引入STL的list容器。

本來，使用BCB的TList對象，也可以實現(xiàn)同樣的目的。
但
TLsit類在對象指針的個數(shù)超過5000個時，效率會有明顯的下降。
TList類不是類型安全的，它根本不在乎引入的對象指針是何種類型的。
引入TList類就意味著要包含VCL.h頭文件，這對我的計算模塊的可移植性實在不是一件好事。

cker做了決定之后，面臨兩個與stl有關(guān)的問題。
第一個問題就是上面提到的如何在STL中處理對象的指針。
CKER的解決之道是創(chuàng)建一個封裝指針的類。
代碼如下：

// 定義一個用于STL容器的指針封裝類
// 因為使用STL不宜直接向容器中添加指針。
////////////////////////////////////////////////////////////////////////////////
class PtrWrapper
{
private:
    X* px;//指向類X的指針

public:
    file://構(gòu)造及拷貝構(gòu)造函數(shù)
    PtrWrapper(X* x = 0) : px(x) {}
    PtrWrapper(const PtrWrapper& pw) : px(pw.px) {}
    file://析構(gòu)函數(shù)
    ~PtrWrapper() {}
    PtrWrapper& operator= (const PtrWrapper& pw) { px = xw.px; }

    file://重載運算符()返回對象X的指針
    const X* operator() () const { return px; }
    X* operator() () { return px; }
};

file://重載邏輯運算符 == , < , >
bool operator== (const PtrWrapper& pw1, const PtrWrapper& pw2) {
    return (pw1.operator()() && pw2.operator()()) ? *pw1() == *pw2() : false;
}

bool operator< (const PtrWrapper& pw1, const PtrWrapper& pw2) {
    return (pw1() && pw2()) ? *pw1() < *pw2() : false;
}

bool operator> (const PtrWrapper& pw1, const PtrWrapper& pw2) {
    return (pw1() && pw2()) ? !(*pw1() < *pw2()) : false;
}


上述代碼封裝了一個指針。經(jīng)過類PtrWrapper的封裝后，您就沒有必要直接使用指針了。
STL容器接觸的是真正的對象，只不過這個對象封裝了一個特定類型的指針。
下面舉例說明PtrWrapper的使用。


// 假設(shè)您需要將指向類X的對象的指針放入STL容器。
//
class X
{
private:
    int I;

public:
    file://構(gòu)造函數(shù)，拷貝構(gòu)造函數(shù)，析構(gòu)函數(shù)
    X(int i) : I(i) {}
    X(const X& x) : I(x.I) {}
    ~X() {}
    file://重載運算符= ,()
    X& operator= (const X& x) { I = x.I; }

    int operator()() const { return I; }
};
file://重載邏輯運算符
bool operator== (const X& x1, const X& x2) {
    return x1() == x2();
}

bool operator< (const X& x1, const X& x2) {
    return x1() < x2();
}




file://下面是示例主程序
int main(int, char*[]) {
    PtrWrapper bucket[5];
    for(int i = 0; i < 5; ++i) {
        bucket[i] = PtrWrapper(new X(i * i));
    }
    random_shuffle(bucket, bucket + 5);

    list<PtrWrapper> list1;
    copy(bucket, bucket + 5,
        back_insert_iterator<list<PtrWrapper> > (list1)
    );

    cout << "List of PtrWrapper: (";
    for_each(list1.begin(), list1.end(), print);
    cout << ")" << endl;

    set<PtrWrapper, greater<PtrWrapper> > set1;
    copy(list1.begin(), list1.end(),
        insert_iterator<set<PtrWrapper, greater<PtrWrapper> > >
            (set1, set1.begin())
    );

    cout << "Set of PtrWrapper : [";
    for_each(set1.begin(), set1.end(), print);
    cout << "]" << endl;

   deque<PtrWrapper> deque1;
    copy(list1.begin(), list1.end(),
        back_insert_iterator<deque<PtrWrapper> > (deque1)
    );

    cout << "Deque of PtrWrapper : (";
    for_each(deque1.begin(), deque1.end(), print);
    cout << ")" << endl;

    return 0;
}

還有一個問題是如何在STL容器種存放派生類對象，下次討論。

注：文中的代碼原型來自于Internet，可惜網(wǎng)址沒留下來。CKER整理之后貼出來，姑且妄稱原創(chuàng)了。

您可以隨意復(fù)制、分發(fā)、下載此文檔。但未經(jīng)本人同意，您不可以截取、改動本文片斷，或用本文謀取任何形式的利益。
有任何意見和建議請mailto：[email protected]