blocks|key|4322988|text|冒着引用你的链接的风险..|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4322989|将迭代器的类别标识为正向迭代器的|4322990|空类：|blockquote|4322991|4322992|4322993|它被用作标识迭代器类型的标记，以便函数(这里是_M_range_insert+)可以适当地执行操作。因为它是一个类型名称，所以可以用来触发不同的重载。|offset|length|style|CODE|4322994|在我的实施中，我有|4322995|void+_Insert(const_iterator+_Where,+_Iter+_First,+_Iter+_Last,
++++++++++++_Int_iterator_tag)

void+_Insert(const_iterator+_Where,+_Iter+_First,+_Iter+_Last,
++++++++++++input_iterator_tag)

void+_Insert(const_iterator+_Where,+_Iter+_First,+_Iter+_Last,+
++++++++++++forward_iterator_tag)|code-block|syntax|javascript|4322996|在其他重载中。|4322997|entityMap^0|0|0|0|0|0|N|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|10|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|11|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|12|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|13|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|14|8|@$K|15|L|16|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|17|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|18|8|@]|9|@]|A|$T|U]]|$1|V|3|W|5|6|7|19|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|Y|$]]

At the risk of quoting your link..

<blockquote>
 Empty class to identify the category of an iterator as a forward iterator:
</blockquote>

It is used as a tag to identify the kind of iterator, so that the functions, here <code>_M_range_insert</code> can act appropriately. Since it is a type name, it can be used to trigger different overloads.

In my impl, I have 

<pre><code>void _Insert(const_iterator _Where, _Iter _First, _Iter _Last,
 _Int_iterator_tag)

void _Insert(const_iterator _Where, _Iter _First, _Iter _Last,
 input_iterator_tag)

void _Insert(const_iterator _Where, _Iter _First, _Iter _Last, 
 forward_iterator_tag)
</code></pre>

Among other overloads.

blocks|key|779924|text|来区分不同的_M_range_insert重载。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|779925|This+reference看起来更好一些，并且有一个关于如何使用标签结构的例子。|779926|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/iterator/iterator_tags^0|6|F|0|0|E|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@$9|T|A|U|1|V]]|E|$]]|$1|H|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]]]

To distinguish between different <code>_M_range_insert</code> overloads.

<a href="http://en.cppreference.com/w/cpp/iterator/iterator_tags">This reference</a> seems a little better, and has an example on how the tag structures can be used.

blocks|key|2196633|text|它是模板元编程机制的一部分，它用于根据参数的特征选择适当的重载，例如，如果你有随机访问迭代器，你可以利用它来检查它们之间的距离，并在插入之前保留。另一方面，如果你只有正向迭代器，检查距离将是O(n)，所以你不这样做，只需向后推，这可能会导致多次重新定位，因此速度会更慢。此外，编译器会优化出这些空结构，因此没有运行时损失。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2196634|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It's a part of template metaprogramming machinery and it is used to choose appropriate overload based on traits of arguments, so for example if you have random access iterators you can take advantage of that and check distance between them and reserve before insert. On the other hand if you only have forward iterators checking distance would be O(n), so you don't do it, just push back, which can result in multiple relocations and therefore be slower.
Also compiler will optimize out these empty structs, so there is no runtime penalty.

blocks|key|782781|text|简而言之:标签用于重载，用于优化。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|782782|以一个简单的advance为例，您可以设计：|offset|length|style|CODE|782783|template<class+II,+class+D>
void+advance(II&+i,+D+n){
++++while(+n--+)+%2B%2Bi;
}|code-block|syntax|javascript|782784|但是，它具有O(n)复杂性，这在您使用random_access_iterator时是不可接受的。所以你可以像这样改变你的设计：|782785|template<class+II,+class+D>
void+advance_II(II&+i,+D+n){
++++while(+n--+)+%2B%2Bi;
}

template<class+RAI,+class+D>
void+advance_RAI(RAI&+i,+D+n){
++++i+%2B=+n;
}

template<class+II,+class+D>
void+advance(II&+i,+D+n){
++++if(is_random_access_iterator(i))+//+not+yet+designed
++++++++advance_RAI(i,+n);
++++else
++++++++advance_II(i,+n);
}|782786|然而，要使用的函数的版本是在运行时决定的，因此我们尝试让编译器在编译时决定选择哪种方法。所以我们给迭代器加上标签。有五个标签：|BOLD|782787|struct+input_iterator_tag+{};
struct+output_iterator_tag+{};
struct+forward_iterator_tag+:+public+input_iterator_tag+{};
struct+bidirection_iterator_tag+:+public+forward_iterator_tag+{};
struct+random_access_iterator_tag+:+public+bidirection_iterator_tag+{};|782788|现在你可以这样做了：|782789|template<class+II,+class+D>
void+__advance(II&+i,+D+n,+input_iterator_tag){
++++while(+n--+)+%2B%2Bi;
}

template<class+RAI,+class+D>
void+__advance(RAI&+i,+D+n,+random_access_iterator_tag){
++++i+%2B=+n;
}

template<class+II,+class+D>
void+advance(II&+i,+D+n){
++++__advance(i,+n,+iterator_traits<II>::iterator_category());
}|782790|entityMap^0|0|6|7|0|0|6|4|J|M|0|0|1I|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@$D|13|E|14|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|16|8|@$D|17|E|18|F|G]|$D|19|E|1A|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|1B|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|1C|8|@$D|1D|E|1E|F|S]]|9|@]|A|$]]|$1|T|3|U|5|J|7|1F|8|@]|9|@]|A|$K|L]]|$1|V|3|W|5|6|7|1G|8|@]|9|@]|A|$]]|$1|X|3|Y|5|J|7|1H|8|@]|9|@]|A|$K|L]]|$1|Z|3|-4|5|6|7|1I|8|@]|9|@]|A|$]]]|10|$]]

<h3>In a nutshell: Tags are for overloading, for optimization.</h3>
Take a simple <code>advance</code> as example, you might design:
<pre><code>template&lt;class II, class D&gt;
void advance(II&amp; i, D n){
 while( n-- ) ++i;
}
</code></pre>
However it have <code>O(n)</code> complexity, which is not acceptable when you have a <code>random_access_iterator</code>. So you may change your design like this:
<pre><code>template&lt;class II, class D&gt;
void advance_II(II&amp; i, D n){
 while( n-- ) ++i;
}

template&lt;class RAI, class D&gt;
void advance_RAI(RAI&amp; i, D n){
 i += n;
}

template&lt;class II, class D&gt;
void advance(II&amp; i, D n){
 if(is_random_access_iterator(i)) // not yet designed
 advance_RAI(i, n);
 else
 advance_II(i, n);
}
</code></pre>
However the version of function to use is decided at run-time, so we try to let compiler decided which method to choose at compile-time. So we give iterators tags. There are five tags:
<pre><code>struct input_iterator_tag {};
struct output_iterator_tag {};
struct forward_iterator_tag : public input_iterator_tag {};
struct bidirection_iterator_tag : public forward_iterator_tag {};
struct random_access_iterator_tag : public bidirection_iterator_tag {};
</code></pre>
Now you can do this:
<pre><code>template&lt;class II, class D&gt;
void __advance(II&amp; i, D n, input_iterator_tag){
 while( n-- ) ++i;
}

template&lt;class RAI, class D&gt;
void __advance(RAI&amp; i, D n, random_access_iterator_tag){
 i += n;
}

template&lt;class II, class D&gt;
void advance(II&amp; i, D n){
 __advance(i, n, iterator_traits&lt;II&gt;::iterator_category());
}
</code></pre>

blocks|key|4323190|text|有几个用于插入到向量中的重载，其中一些重载是为构造函数复制的。如果向量元素是整型的，那么其中两个重载会发生冲突：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4323191|iterator+insert(+const_iterator+pos,+size_type+count,+const+T&+value+);

template<+class+InputIt+>
iterator+insert(+const_iterator+pos,+InputIt+first,+InputIt+last+);|code-block|syntax|javascript|4323192|如果你有一个vector<int>并调用vec.insert(vec.bgein(),+5,+4)，你肯定是想插入值4的5倍。但是重载解析会看到这个模板并调用它，从而推断出InputIt为int。|offset|length|style|CODE|4323193|为了解决这个问题和其他一些行为问题，标准库的实现者发明了一些特征和一堆标记类。特征是一个模板元函数，它将提供三个不同的标签，就像Karthik+T在他的回答中所说的那样：|4323194|如果type|4323195|forward_iterator_tag是前向迭代器，则为|unordered-list-item|4323196|_Int_iterator_tag；如果InputIt是不是前向迭代器的迭代器类型，则为|4323197|4323198|4323199|然后，您将有一堆_M_range_insert重载，将不同的标记类型作为附加参数，每个参数都做正确的事情，这意味着|4323200|Int-|4323201|的重载将重定向到insert的第一个非模板化重载(或者它的正向迭代器的implementation)|4323202|
|4323203|The重载调用reserve(std::distance(first,last))并从迭代器范围中复制元素，在该|4323204|4323205|之后，普通输入迭代器的重载只是复制元素，可能会导致多次重新分配。它不能调用reserve，因为输入迭代器只能计算一次(例如istream迭代器)|4323206|4323207|然后，模板化的插入方法在概念上将如下所示：|4323208|template<+class+InputIt+>
iterator+insert(+const_iterator+pos,+InputIt+first,+InputIt+last+)
{
++return+_M_range_insert(pos,+first,+last,+InsertIteratorTraits<InputIt>::tag_type());
}|4323209|entityMap^0|0|0|6|B|K|T|2E|7|2M|3|0|0|0|0|K|0|0|H|K|7|0|0|0|8|F|0|0|8|6|0|0|7|Y|0|0|11|7|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1H|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1I|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1J|8|@$I|1K|J|1L|K|L]|$I|1M|J|1N|K|L]|$I|1O|J|1P|K|L]|$I|1Q|J|1R|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|1S|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1T|8|@]|9|@]|A|$]]|$1|Q|3|R|5|S|7|1U|8|@$I|1V|J|1W|K|L]]|9|@]|A|$]]|$1|T|3|U|5|S|7|1X|8|@$I|1Y|J|1Z|K|L]|$I|20|J|21|K|L]]|9|@]|A|$]]|$1|V|3|-4|5|6|7|22|8|@]|9|@]|A|$]]|$1|W|3|-4|5|6|7|23|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|24|8|@$I|25|J|26|K|L]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|27|8|@]|9|@]|A|$]]|$1|11|3|12|5|S|7|28|8|@$I|29|J|2A|K|L]]|9|@]|A|$]]|$1|13|3|14|5|6|7|2B|8|@]|9|@]|A|$]]|$1|15|3|16|5|S|7|2C|8|@$I|2D|J|2E|K|L]]|9|@]|A|$]]|$1|17|3|14|5|6|7|2F|8|@]|9|@]|A|$]]|$1|18|3|19|5|S|7|2G|8|@$I|2H|J|2I|K|L]]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|2J|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|2K|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|D|7|2L|8|@]|9|@]|A|$E|F]]|$1|1F|3|-4|5|6|7|2M|8|@]|9|@]|A|$]]]|1G|$]]

There are several overloads for insertion into a vector, some of them are duplicated for the constructors. Two of those overloads have a conflict if the vector elements are of integral type:

<pre><code>iterator insert( const_iterator pos, size_type count, const T&amp; value );

template&lt; class InputIt &gt;
iterator insert( const_iterator pos, InputIt first, InputIt last );
</code></pre>

If you have a <code>vector&lt;int&gt;</code> and call <code>vec.insert(vec.bgein(), 5, 4)</code>, you surely mean to insert 5 times the value 4. But overload resolution will see the template and call that one, deducing <code>InputIt</code> to be <code>int</code>. 

To solve that problem and some other behavioral stuff, the implementors of the standard library have invented some traits and a bunch of tag classes. The traits is a template metafunction that will give three different tags, like Karthik T said in his answer:

<ul>
<li><code>_Int_iterator_tag</code> if <code>InputIt</code> is of integral type</li>
<li><code>forward_iterator_tag</code> if <code>InputIt</code> is a forward iterator (that includes random access iterators)</li>
<li><code>input_iterator_tag</code> if <code>InputIt</code> is an iterator type that is not a forward iterator</li>
</ul>

You will then have a bunch of overloads of <code>_M_range_insert</code>, taking the different tag types as additional parameters, each doing the Right Thing, meaning 

<ul>
<li>The overload for the Int-Tag will redirect to the first non-templated overload of <code>insert</code> (or its implementation)</li>
<li>The overload for forward-iterators calls <code>reserve(std::distance(first,last))</code> and copies the elements from the iterator range after that</li>
<li>The overload for plain input iterators just copies the elements, maybe causing multiple reallocations. It cannot call <code>reserve</code>, because the input iterators can be evaluated only once (thing e.g. of istream iterators)</li>
</ul>

The templated insert method will then look conceptually like this:

<pre><code>template&lt; class InputIt &gt;
iterator insert( const_iterator pos, InputIt first, InputIt last )
{
 return _M_range_insert(pos, first, last, InsertIteratorTraits&lt;InputIt&gt;::tag_type());
}
</code></pre>

Upon profiling an application, I bumped into that piece of the standard library implementation shipped with gcc 4.7.1. It is <code>include/g++-v4/bits/vector.tcc</code>:

<pre><code>template&lt;typename _Tp, typename _Alloc&gt;
template&lt;typename _ForwardIterator&gt;
 void
 vector&lt;_Tp, _Alloc&gt;::
 _M_range_insert(iterator __position, _ForwardIterator __first,
 _ForwardIterator __last, std::forward_iterator_tag)
 {
 …
 }
</code></pre>

I noticed that the last argument of the function signature is just a tag, and I started wondering why it was here. A quick look at <a href="http://www.cplusplus.com/reference/iterator/ForwardIterator/" rel="noreferrer">this page</a> shows that <code>std::forward_iterator_tag</code> is an empty structure. What is its role here? Clearly it's useless to the function, and it might waste a register, or some space on the stack. So why?

What is the role of std::forward_iterator_tag?

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在分析应用程序时，我遇到了与gcc 4.7.1一起提供的标准库实现部分。它是include/g++-v4/bits/vector.tcctemplate<typename _Tp, typename _Alloc>template<typename _ForwardIterator> void vector<_Tp...

问std::forward_iterator_tag的作用是什么？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问std::forward_iterator_tag的作用是什么？EN