blocks|key|891438|text|使用模板：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|891439|template+<size_t+N>
void+foo(std::array<bool,N>::const_iterator+begin,+std::array<bool,N>::const_iterator+end)
{
++++printf("iterator");
}|code-block|syntax|javascript|891440|现在，只要两个迭代器都来自一个大小为N的数组，这个函数就能工作。|offset|length|style|CODE|891441|如果要接受来自不同大小数组的迭代器，只需为第二个迭代器添加另一个模板参数，如|891442|template+<size_t+N,+size_t+M>
void+foo(std::array<bool,N>::const_iterator+begin,+std::array<bool,M>::const_iterator+end)
{
++++printf("iterator");
}|891443|entityMap^0|0|0|I|1|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Use a template:

<pre><code>template &lt;size_t N&gt;
void foo(std::array&lt;bool,N&gt;::const_iterator begin, std::array&lt;bool,N&gt;::const_iterator end)
{
 printf("iterator");
}
</code></pre>

And now as long as both iterators come from an array of size <code>N</code> this function will work.

<hr>

If you want to accept iterators from different sized arrays, you just need to add another template parameter for the second iterator like

<pre><code>template &lt;size_t N, size_t M&gt;
void foo(std::array&lt;bool,N&gt;::const_iterator begin, std::array&lt;bool,M&gt;::const_iterator end)
{
 printf("iterator");
}
</code></pre>

blocks|key|891457|text|您只需将其作为函数模板|type|unstyled|depth|inlineStyleRanges|entityRanges|data|891458|template+<typename+I>
void+foo(I+begin,+I+end)
{
++++std::cout+<<+"iterator";
}|code-block|syntax|javascript|891459|您不需要关心容器类型(以及大小)，您可以传递std::array、std::vector和std::string等迭代器，甚至是原始指针(这也满足迭代器的要求)。|offset|length|style|CODE|891460|entityMap^0|0|0|M|A|X|B|19|B|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]|$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|N|$]]

You can just make it a function template as

<pre><code>template &lt;typename I&gt;
void foo(I begin, I end)
{
 std::cout &lt;&lt; "iterator";
}
</code></pre>

You don't need to care about container type (and the size), you can pass iterators of <code>std::array</code>, <code>std::vector</code> and <code>std::string</code> and so on, even raw pointers (which also satisfies iterator's requirements).

blocks|key|891483|text|如果函数在引用std：：数组冗余时接受两个迭代器。只需将函数声明为|type|unstyled|depth|inlineStyleRanges|entityRanges|data|891484|template+<class+Iterator>
void+foo(+Iterator+first,+Iterator+last+);|code-block|syntax|javascript|891485|在声明中，您可以命名与函数中使用的迭代器类型相对应的迭代器，例如|891486|template+<class+ForwardIterator>
void+foo(+ForwardIterator+first,+ForwardIterator+last+);|891487|或者，您可以使用名称ForwardIterator代替名称BidirectionalIterator或RandomAccessIterator进行自文档化。|offset|length|style|CODE|891488|如果需要知道迭代器的值类型，可以使用不同的方法。例如|891489|template+<class+Iterator>
void+foo(+Iterator+first,+Iterator+last+)
{
++++using+value_type+=+typename+std::iterator_traits<Iterator>::value_type;
++++if+(+first+!=+last+)
++++{
+++++++++value_type+item1+=+*first;
+++++++++//+or
+++++++++auto+item2+=+*first;
+++++++++//
+++++++++const+auto+&item3+=+*first;
+++++++++//...+++++++++++++
++++}
}|891490|在这种情况下，您将有一个灵活的函数定义。例如，如果将来将std::array<N,+bool>更改为std::vector<bool>，则该函数将像往常一样工作。|891491|entityMap^0|0|0|0|0|A|F|T|L|1F|K|0|0|0|S|J|1E|H|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@$M|13|N|14|O|P]|$M|15|N|16|O|P]|$M|17|N|18|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1B|8|@$M|1C|N|1D|O|P]|$M|1E|N|1F|O|P]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|X|$]]

If the function accepts two iterators when the referring std::array is redundant. Just declare the function like

<pre><code>template &lt;class Iterator&gt;
void foo( Iterator first, Iterator last );
</code></pre>

In the declaration you can name the iterator that corresponds to the used iterator type in the function like for example

<pre><code>template &lt;class ForwardIterator&gt;
void foo( ForwardIterator first, ForwardIterator last );
</code></pre>

Or instead of the name <code>ForwardIterator</code> you could use the name <code>BidirectionalIterator</code> or <code>RandomAccessIterator</code> for self-documenting.

If you need to know the value type of the iterator you can use different approaches. For example

<pre><code>template &lt;class Iterator&gt;
void foo( Iterator first, Iterator last )
{
 using value_type = typename std::iterator_traits&lt;Iterator&gt;::value_type;
 if ( first != last )
 {
 value_type item1 = *first;
 // or
 auto item2 = *first;
 //
 const auto &amp;item3 = *first;
 //... 
 }
}
</code></pre>

In this case you will have a flexible function definition. For example if in future you will change <code>std::array&lt;N, bool&gt;</code> to <code>std::vector&lt;bool&gt;</code> the function will as usual work.

blocks|key|891523|text|只需使用span|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|891524|#include+<array>
#include+

class+MyInterface+{
public:
++++virtual+void+foo(std::span<bool>+barr)+=+0;

++++//+interface+destructors+should+be+virtual
++++virtual+~MyInterface()+=+default;
};

void+bar(MyInterface&+interface)+{
++++std::array<bool,+42>+arr;
++++interface.foo(arr);
}|code-block|syntax|javascript|891525|如果您无法访问C%2B%2B20编译器，则可以使用来自谷胱甘肽的gsl::span。|891526|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/microsoft/GSL|1|https://github.com/microsoft/GSL/blob/master/include/gsl/span^0|4|4|0|0|S|9|N|4|0|S|9|1|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]|$9|16|A|17|1|18]]|E|$]]|$1|M|3|-4|5|6|7|19|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

Just use <code>span</code>:

<pre><code>#include &lt;array&gt;
#include &lt;span&gt;

class MyInterface {
public:
 virtual void foo(std::span&lt;bool&gt; barr) = 0;

 // interface destructors should be virtual
 virtual ~MyInterface() = default;
};

void bar(MyInterface&amp; interface) {
 std::array&lt;bool, 42&gt; arr;
 interface.foo(arr);
}
</code></pre>

If you don't have access to a C++20 compiler, you may use <a href="https://github.com/microsoft/GSL/blob/master/include/gsl/span" rel="nofollow noreferrer"><code>gsl::span</code></a> from <a href="https://github.com/microsoft/GSL" rel="nofollow noreferrer">gsl</a> instead.

I am implementing a function that wants to loop over a number of elements in an std::array, but I don't really care how long the std::array is. So I was thinking of the following function:

<pre class="lang-cpp prettyprint-override"><code>#include &lt;stdio.h&gt;
#include &lt;array&gt;
#include &lt;iterator&gt;

void foo(std::array&lt;bool,0&gt;::const_iterator begin, std::array&lt;bool,0&gt;::const_iterator end)
{
 printf("iterator");
}

int main()
{
 std::array&lt;bool, 25&gt; one;
 std::array&lt;bool, 33&gt; two;

 foo(one.cbegin(), one.cend());
 foo(two.cbegin(), two.cend());
}
</code></pre>

I am quite okay with this, except for the <code>std::array&lt;bool,0&gt;</code>. My question is, is there another way to specify the iterator that is required for this function?

<hr>

Update

There are some things I should mention. Of course this code is part of a bigger scope and I tried to hide as much detail as I could.

<ol>
<li>I want to ensure that the iterator being used is of <code>bool</code>s.</li>
<li>I am using C++14</li>
<li>The function is part of a class interface and I want to be able to handle multiple array sizes. I don't want to bother the implementors of the interface to know exactly what the size of the array is.</li>
</ol>

<pre class="lang-cpp prettyprint-override"><code>class MyInterface
{
public:
 virtual foo(std::array&lt;bool,0&gt;::const_iterator begin, std::array&lt;bool,0&gt;::const_iterator end) = 0;

 ~MyInterface() = default;
};
</code></pre>

I remembered that virtual functions cannot be templated. That means I would have to template my whole interface and that would exactly loose the point of why I was trying this in the first place.

std::array::iterator that ignores the size template

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我正在实现一个函数，它希望循环一个std：：数组中的许多元素，但我并不关心std::array有多长时间。所以我想到了以下功能：#include <stdio.h>#include <array>#include <iterator>void foo(std::array<bool,0>::const_iterator...

问std::array::iterator忽略大小模板
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问std::array::iterator忽略大小模板EN