for(auto) loop in print function 抛出错误，为什么？

Question

The for loop in main compiles fine but in the print function it doesn't, with the diagnostic

for(auto i:x) cout<<i<<" ";        

  -----------^std::end  
'end' was not declared in this scope; did you mean 'std::end'?

being issued. Here's the full code:

#include <iostream>
void print(int x[],int n)
{
   for(auto i:x) std::cout<<i<<" ";
}

int main()
{
    int arr[] = {1, 5, 2, 1, 4, 3, 1, 7, 2, 8, 9, 5};
    int n = sizeof(arr) / sizeof(int);
    for(auto i:arr)
        std::cout<<i<<" ";
    print(arr, n);
    return 0;
}

Answer 1

The issue is that the array arr decays to a pointer when passed to the function print . The mechanism behind the range-based for loop is via the use of std::begin and std::end . That goes some way in explaining the compiler diagnostic: they don't work if applied to pointer types.

This pointer decay is the normal behavior when passing array parameters to functions, but is by no means universal. For example, std::begin and std::end obviate this with some template trickery (otherwise they'd be useless for array types), something which you can do too by writing

template<typename T>
void print(T&& x, int n)
{
   for(auto i:x) std::cout<<i<<" ";
}

instead.

Answer 2

The plain old datatype int[] has no end-iterator , if you pass it to a function. In this case you yust pass a pointer to the first item. In order to use a range based for loop you have to use a data container, which has a begin- and end-iterator, such as std::vector

Here is your code in a more C++ way.

#include<vector>
#include<iostream>
    
void print(const std::vector<int> &x) {
    for(auto i:x) {
       std::cout<<i<<" ";
    }
}

int main() {
    const std::vector<int> arr {1, 5, 2, 1, 4, 3, 1, 7, 2, 8, 9, 5};
    for(auto i:arr) {
        std::cout << i << " ";
    }

    print(arr);
    return 0;
}

Answer 3

@schorsch312's answer is correct, but the suggestion to have the print() function take an std::vector is not the "C++ way": Using std::vector instead of a plain array in your main program is just fine, but when writing a function - I would recommend not to take a type more specific than what you actually need to perform the function's work, and specifically not allocate memory on the heap with a new vector.

For the case of you having a C array in your program, @Bathsheba's suggestion of a print() is better in my opinion, in that it will allow you to pass the array as-such, and thus iterate over it properly.

However - for pedagogical reasons, I would suggest you consider this version print() :

template <std::size_t N>
void print(const int (&arr)[N]) {
    for(auto i : arr) {
       std::cout << i << " ";
    }
}

which illustrates how print() can take an array reference. You need the template when you don't know the array size apriori. (and this also works of course.)

Alternatively, you could use the standard library algorithm, std::for_each , like so:

#include <vector>
#include <iostream>
#include <algorithm>

int main()
{
    int arr[] {1, 5, 2, 1, 4, 3, 1, 7, 2, 8, 9, 5};
    for(auto i:arr) {
        std::cout << i << ' ';
    }
    std::cout << '\n';
    std::for_each(
        std::begin(arr), std::end(arr),
        [](auto i) { std::cout << i << ' '; }
    );
}

Note that when you use the ranged-for loop, what happens is basically the equivalent of the for_each invocation, or of a raw for loop over an iterator beginning at std::begin(arr) and ending at std::end(arr) .

Yet another alternative - which does not require concerning yourself with iterator pairs - is to have a print() function taking a span ( What is a "span" and when should I use one? ). Here it makes some sense since a plain C array can be referred to by a span: It has contiguous element storage and a specific length. If you were to be using C++20, your span-using print function would look like this:

#include <span> 

void print(const std::span<int> &sp) {
    for(auto i : sp) {
       std::cout << i << ' ';
    }
}

and again you don't have to specify the length in your main function. C++14 doesn't have spans in the standard library, but the C++ Guidelines Support Library (see here or here ) has it, as gsl::span - and it works in C++14.

---

Nitpicks:

• There is no need to return 0 from main() - that happens automatically.
• Please use spaces between #include directives and the angle-brackets (ie #include <foo> , not #include <foo> .
• Please use spaces before and after << operators.
• To print a space, you don't need a string; the single space character suffices, ie std::cout << ' ' rather than std::cout << " " .