在STL中处理对象指针

在STL中处理对象指针

众所周知，STL的容器类是针对对象来进行存储管理的。虽然没有明确的限制不能在STL的容
器类中包含指针，STL也不在乎您存放在容器中的对象还是指针。但仔细考虑STL的初衷，
在容器类中使用指针是明显不合时宜的。
CKER的意思是您应该尽可能的直接将对象本身而不是将对象的指针放置在STL容器类中。直接
在容器中存放指针一个最大的副作用就是可能导致内存泄漏。这个问题在char *类型上有突出
的体现。
但某些时候，直接使用对象指针有明显的好处，这些情况大致可以概括为如下的几个方面：
1. 当对象十分庞大时，频繁的拷贝复制所带来的系统资源消耗十分昂贵。
2. 当您需要将同一个对象存放到多个容器中，这种情况应该不是很少见的。
3. 当您需要在同一个容器中存放由同一个父类派生而来的多个派生类对象。这也很常见。
事实上，CKER这个星期所开发的计算程序中，正需要面对第三种情况。考虑使用STL的种种好处。
CKER决定引入STL的list容器。

本来，使用BCB的TList对象，也可以实现同样的目的。
但
TLsit类在对象指针的个数超过5000个时，效率会有明显的下降。
TList类不是类型安全的，它根本不在乎引入的对象指针是何种类型的。
引入TList类就意味着要包含VCL.h头文件，这对我的计算模块的可移植性实在不是一件好事。

cker做了决定之后，面临两个与stl有关的问题。
第一个问题就是上面提到的如何在STL中处理对象的指针。
CKER的解决之道是创建一个封装指针的类。
代码如下：

// 定义一个用于STL容器的指针封装类
// 因为使用STL不宜直接向容器中添加指针。
////////////////////////////////////////////////////////////////////////////////
class PtrWrapper
{
private:
    X* px;//指向类X的指针

public:
    file://构造及拷贝构造函数
    PtrWrapper(X* x = 0) : px(x) {}
    PtrWrapper(const PtrWrapper& pw) : px(pw.px) {}
    file://析构函数
    ~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;
}

上述代码封装了一个指针。经过类PtrWrapper的封装后，您就没有必要直接使用指针了。
STL容器接触的是真正的对象，只不过这个对象封装了一个特定类型的指针。
下面举例说明PtrWrapper的使用。

// 假设您需要将指向类X的对象的指针放入STL容器。
//
class X
{
private:
    int I;

public:
    file://构造函数，拷贝构造函数，析构函数
    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，可惜网址没留下来。CKER整理之后贴出来，姑且妄称原创了。

您可以随意复制、分发、下载此文档。但未经本人同意，您不可以截取、改动本文片断，或用本文谋取任何形式的利益。
有任何意见和建议请mailto：cker@sina.com