有没有办法限制STL::map容器的最大大小？
有没有办法限制STL::map容器的最大大小？
提问于 2011-01-19 03:35:37
我的应用程序在map结构中最多只能处理一定数量的条目，我如何在代码中指定该限制，以便我的代码不会被淹没(因为缺少更好的术语)。在定义map类型的变量时，有没有办法指定最大限制？
谢谢
回答 3
Stack Overflow用户
回答已采纳
发布于 2011-01-19 03:41:46
没有办法在实例化地图时设置限制，尽管我认为你可以在访问地图时有自己的安全保护。例如：
if (mymap.find(a) == mymap.end() and mymap.size() >= MAX_MAP_ALLOWED) {
throw (runtime_error("map limit exceeded"));
} else {
mymap[a] = b;
}您可以创建自己的map类来封装这些检查。
Stack Overflow用户
发布于 2011-01-19 03:41:18
stl容器也接受'allocator‘作为(默认的)参数。这个分配器是容器为其数据分配新空间的方法。
如果你定义了一个“上限”分配器(听起来很简单，对吧？)，你就成功了。
编辑-在一些论坛中，我发现分配器，虽然最初的目的是无状态的，但在大多数(现代)编译器上可以是全状态的。这就是为什么我会坚持下去。不过，这样做相当麻烦，而且在cappedmap适配器中聚合映射类型可能会更容易、更容易理解。
我花了很多时间，但这里我得到了一个编译，封顶的例子：
// an allocator with maximally MAX elements.
template< typename T, size_t MAX = 5 >
struct AllocateCapped {
// reuses an existing allocator
typedef std::allocator<T> tallocator;
typedef typename tallocator::value_type value_type;
typedef typename tallocator::pointer pointer;
typedef typename tallocator::reference reference;
typedef typename tallocator::const_pointer const_pointer;
typedef typename tallocator::const_reference const_reference;
typedef typename tallocator::size_type size_type;
typedef typename tallocator::difference_type difference_type;带上限的分配器的实际代码委托给allocator成员：
size_t free;
tallocator allocator;
AllocateCapped():free(MAX){
printf("capped");
}
template<typename T2>
AllocateCapped( const AllocateCapped<T2>& other ){}
pointer allocate( size_type n, const_pointer hint = 0) {
if( !free ) throw std::bad_alloc();
free-=n;
return allocator.allocate( n, hint );
}
void deallocate( pointer p, size_type n ) {
free+=n;
allocator.deallocate(p,n);
}
size_type max_size() const { return free; }
void construct( pointer p, const_reference val ) {
return allocator.construct(p,val);
}
void destroy( pointer p ) { allocator.destroy(p); }
template<class _Other>
struct rebind
{ // convert this type to _ALLOCATOR<_Other>
typedef typename AllocateCapped<_Other> other;
};
};这个分配器可以像这样使用：
// example structure
struct s {
int i;
s():i(){}
s(int i):i(i){}
};
int main(int argc, char* argv[]) {
typedef AllocateCapped< std::pair<const int, s> > talloc;
talloc a;
talloc::pointer p = reinterpret_cast<talloc::pointer>( a.allocate(1,0) );
a.construct(p, talloc::value_type() );
a.destroy(p);
a.deallocate(p, 1 );
std::map<int , s, std::less<int>, talloc > m;
std::vector<int, AllocateCapped<int> > v;
for( int i = 0; i != 4; ++i ) {
m[i]=s(i);
v.push_back(i);
}
m[5]=s(5); // throws
v.push_back(5); // throws
return 0;
}注意:未经过彻底测试。这只是一个想法。
Stack Overflow用户
发布于 2011-01-22 20:28:27
在尝试了上限分配器的想法之后，我认为聚合一个std::map会更简单(注意:不是继承自！至少不是公开的)在cappedadaptor中。
template<typename tKey, typename tVal> class cappedmap {
typedef std::map<tKey,tVal> tmap;
tmap mymap;
cappedmap(size_t amax):mymax(amax){}
// adapt the map interface
pair<tmap::iterator,bool> insert( tmap::value_type kv ) {
if( mymap.size() > mymax ) throw myexcept();
return mymap.insert(kv);
}
tVal operator[]( tKey k ) {
tVal v = mymap[k];
if( mymap.size() > mymax ) {
mymap.remove(k)
throw myexcept();
}
}
...
};页面原文内容由Stack Overflow提供。腾讯云小微IT领域专用引擎提供翻译支持
原文链接：
https://stackoverflow.com/questions/4728219
复制相关文章
相似问题
腾讯云开发者
