忽略大小模板的 std::array::iterator

Question

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:

#include <stdio.h>
#include <array>
#include <iterator>

void foo(std::array<bool,0>::const_iterator begin, std::array<bool,0>::const_iterator end)
{
    printf("iterator");
}

int main()
{
    std::array<bool, 25> one;
    std::array<bool, 33> two;

    foo(one.cbegin(), one.cend());
    foo(two.cbegin(), two.cend());
}

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

---

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.

1. I want to ensure that the iterator being used is of bool s.
2. I am using C++14
3. 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.

class MyInterface
{
public:
    virtual foo(std::array<bool,0>::const_iterator begin, std::array<bool,0>::const_iterator end) = 0;

    ~MyInterface() = default;
};

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.

Answer 1

You can just make it a function template as

template <typename I>
void foo(I begin, I end)
{
    std::cout << "iterator";
}

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

Answer 2

Just use span :

#include <array>
#include <span>

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);
}

If you don't have access to a C++20 compiler, you may use gsl::span from gsl instead.

Answer 3

Use a template:

template <size_t N>
void foo(std::array<bool,N>::const_iterator begin, std::array<bool,N>::const_iterator end)
{
    printf("iterator");
}

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

---

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

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");
}

Answer 4

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

template <class Iterator>
void foo( Iterator first, Iterator last );

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

template <class ForwardIterator>
void foo( ForwardIterator first, ForwardIterator last );

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

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

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;
         //...             
    }
}

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