在STL中处理惩罚工具指针

副标题#e#

众所周知，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的封装后，您就没有须要直接利用指针了。

#p#副标题#e#

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整理之后贴出来，暂时妄称原创了。

您可以随意复制、分发、下载此文档。但未经本人同意，您不行以截取、窜改本文片段，或用本文谋取任何形式的好处。