blocks|key|1682158|text|stl容器也接受'allocator‘作为(默认的)参数。这个分配器是容器为其数据分配新空间的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1682159|如果你定义了一个“上限”分配器(听起来很简单，对吧？)，你就成功了。|1682160|编辑-在一些论坛中，我发现分配器，虽然最初的目的是无状态的，但在大多数(现代)编译器上可以是全状态的。这就是为什么我会坚持下去。不过，这样做相当麻烦，而且在cappedmap适配器中聚合映射类型可能会更容易、更容易理解。|1682161|我花了很多时间，但这里我得到了一个编译，封顶的例子：|1682162|//+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;|code-block|syntax|javascript|1682163|带上限的分配器的实际代码委托给allocator成员：|style|CODE|1682164|++++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%2B=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;
++++};

};|1682165|这个分配器可以像这样使用：|1682166|//+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;+%2B%2Bi+)+{
++++m[i]=s(i);
++++v.push_back(i);
}
m[5]=s(5);+//+throws
v.push_back(5);+//+throws
return+0;
}|1682167|注意:未经过彻底测试。这只是一个想法。|1682168|entityMap|0|LINK|mutability|MUTABLE|url|http://www.sgi.com/tech/stl/alloc.html^0|9|9|0|0|0|0|0|0|F|9|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]]|C|$]]|$1|D|3|E|5|6|7|1C|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|1D|8|@]|9|@]|C|$]]|$1|H|3|I|5|6|7|1E|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|1F|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1G|8|@$A|1H|B|1I|Q|R]]|9|@]|C|$]]|$1|S|3|T|5|L|7|1J|8|@]|9|@]|C|$M|N]]|$1|U|3|V|5|6|7|1K|8|@]|9|@]|C|$]]|$1|W|3|X|5|L|7|1L|8|@]|9|@]|C|$M|N]]|$1|Y|3|Z|5|6|7|1M|8|@]|9|@]|C|$]]|$1|10|3|-4|5|6|7|1N|8|@]|9|@]|C|$]]]|11|$12|$5|13|14|15|C|$16|17]]]]

The stl containers also take an '<a href="http://www.sgi.com/tech/stl/alloc.html" rel="nofollow">allocator</a>' as a (defaulted) parameter. This allocator is the container's means to allocate new space for it's data.

If you define a 'capped' allocator (sounds simple, hey?), you're there.

EDIT - In some fora, I found that the allocators, though initially intended stateless, can be statefull on most (modern) compilers. That's why I carry on on this. It's quite cumbersome, though, to do it this way, and probably way more easy and comprenensible to aggregate your map type in a cappedmap adapter.

It took me a lot of moments here and there, but here I got a compiling, capped, example:

<pre><code>// an allocator with maximally MAX elements.
template&lt; typename T, size_t MAX = 5 &gt;
struct AllocateCapped {

 // reuses an existing allocator
 typedef std::allocator&lt;T&gt; 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;
</code></pre>

The actual code of the capped allocator delegates to the <code>allocator</code> member:

<pre><code> size_t free;
 tallocator allocator;

 AllocateCapped():free(MAX){
 printf("capped");
 }

template&lt;typename T2&gt;
 AllocateCapped( const AllocateCapped&lt;T2&gt;&amp; 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&lt;class _Other&gt;
 struct rebind 
 { // convert this type to _ALLOCATOR&lt;_Other&gt;
 typedef typename AllocateCapped&lt;_Other&gt; other;
 };

};
</code></pre>

This allocator can be used like this:

<pre><code>// example structure
struct s {
 int i;
 s():i(){}
 s(int i):i(i){}
};

int main(int argc, char* argv[]) {
typedef AllocateCapped&lt; std::pair&lt;const int, s&gt; &gt; talloc;
talloc a;
talloc::pointer p = reinterpret_cast&lt;talloc::pointer&gt;( a.allocate(1,0) );
a.construct(p, talloc::value_type() );
a.destroy(p);
a.deallocate(p, 1 );

std::map&lt;int , s, std::less&lt;int&gt;, talloc &gt; m;
std::vector&lt;int, AllocateCapped&lt;int&gt; &gt; 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;
}
</code></pre>

Note: not thoroughly tested. It's just an idea.

blocks|key|664807|text|没有办法在实例化地图时设置限制，尽管我认为你可以在访问地图时有自己的安全保护。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|664808|if+(mymap.find(a)+==+mymap.end()+and+mymap.size()+>=+MAX_MAP_ALLOWED)+{
++++throw+(runtime_error("map+limit+exceeded"));
}+else+{
++++mymap[a]+=+b;
}|code-block|syntax|javascript|664809|您可以创建自己的map类来封装这些检查。|664810|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

There's no way to set a limit when instantiating the map, though I supposed you could have your own safe guard when accessing it. For example:

<pre><code>if (mymap.find(a) == mymap.end() and mymap.size() &gt;= MAX_MAP_ALLOWED) {
 throw (runtime_error("map limit exceeded"));
} else {
 mymap[a] = b;
}
</code></pre>

You could possibly create your own map class that encapsulates these checks.

blocks|key|2731578|text|在尝试了上限分配器的想法之后，我认为聚合一个std::map会更简单(注意:不是继承自！至少不是公开的)在cappedadaptor中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2731579|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();
+++++}
+++}
+++...
};|code-block|syntax|javascript|2731580|entityMap^0|M|8|1H|D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

After trying out the idea of a capped allocator, I think it's way more straightforward to aggregate an <code>std::map</code> (note: not inherit-from! At least not publicly) in a <code>cappedadaptor</code>.

<pre><code>template&lt;typename tKey, typename tVal&gt; class cappedmap {
 typedef std::map&lt;tKey,tVal&gt; tmap;
 tmap mymap;

 cappedmap(size_t amax):mymax(amax){}

 // adapt the map interface
 pair&lt;tmap::iterator,bool&gt; insert( tmap::value_type kv ) { 
 if( mymap.size() &gt; mymax ) throw myexcept();
 return mymap.insert(kv);
 }

 tVal operator[]( tKey k ) { 
 tVal v = mymap[k];
 if( mymap.size() &gt; mymax ) { 
 mymap.remove(k)
 throw myexcept();
 }
 }
 ...
};
</code></pre>

My application can only process up to a certain number of entry in the map structure, how do I specify that limit in my code so that my code does not get overwhelmed (for lack of better term). Is there a way to specify the max limit when defining the variable of type map?

Thanks

Is there a way to cap the max size on a STL::map container?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我的应用程序在map结构中最多只能处理一定数量的条目，我如何在代码中指定该限制，以便我的代码不会被淹没(因为缺少更好的术语)。在定义map类型的变量时，有没有办法指定最大限制？谢谢

问有没有办法限制STL::map容器的最大大小？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有办法限制STL::map容器的最大大小？EN