17

It is stated in C++ Primer that

In C++ pointers and arrays are closely intertwined. In particular, as we’ll see, when we use an array, the compiler ordinarily converts the array to a pointer.

I wanted to use iterators for printing an array. The program below works fine but when I try to print arr2 or arr3, if I'm not mistaken, which is of type int *, I get an error (judging that the & operator means reference below).

error: no matching function for call to ‘begin(int*&)’

int main(int argc, char** argv) {

    int arr[] = {0,1,2,3,4,5,6,7,8,9};
    auto arr2 = arr;
    auto arr3(arr);   // I think arr2 and arr3 are of same type

    for(auto it = std::begin(arr) ; it != std::end(arr) ; ++it)
        std::cout << *it << " ";
    std::cout << std::endl;

    return 0;
}

Considering the statement, if an array is converted into a pointer by the compiler, how does this program work for printing contents of arr using std::begin() and std::end() and do not work for arr2 or arr3 if all of them are pointers to integers?

Edit

I'm sorry if I couldn't make it clear. I hope I'll clarify the problem by this edit.

Now that I am aware that begin() and end() won't work with pointers (thanks to the answers), I wonder if the quoted text is not true as it specifies that there is an Array -> Pointer conversion. If what text says is true then the type of arr should be a pointer. Is there a problem with the quoted text at this point?

Also, is there any way that I can use begin() and end() for pointers (not STL containers) with specifying the size, possibly using the following constructor?

template< class T, size_t N > 
T* begin( T (&array)[N] );
Improve this question
1
  • 2
    As for using begin()/end() on pointers: You can't, but you can use the pointer itself as range start and pointer + size as end. Example: std::sort(yourPointer, yourPointer + arraySize) Commented May 8, 2014 at 16:39

4 Answers 4

Reset to default
8

An array is converted to a pointer easily, but not always. For example, if you take the address of the array or get a reference then the original array type isn't lost:

int a[10];
int (&ar)[10] = a; // fine
int (*ap)[10] = &a; // also fine

However, when you use an array in a way where most other types would be copied, the array is converted to a pointer and the pointer is copied instead.

In your example, you can use arr2 if you make it be a reference:

 auto &arr2 = arr;

Now arr2 has type int (&)[10] instead of int *.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Thank you, that precisely answers what I actually ask. +1
3

Because std::begin is defined for arrays but not for pointers. An array type is not the same as a pointer type.

The problem here is that apparently the auto arr2 = arr degrades the type from the array type to a pointer type.

Note that the problem is actually in std::end not in std::begin. After all how would std::end be able to give the pointer to the last+1 element when all it has is a pointer to the first element? It can't, therefore std::end cannot be defined for a pointer type and hence std::begin does not make any sense for a pointer type.

To be precise the type of arr is int[10] while that of arr2 and arr3 is int*. The former can degrade into the latter but not vice versa.

Improve this answer

4 Comments

Does this mean the quoted text is not necessarily true, meaning that the compiler doesn't convert arrays into pointers?
No, the quoted text is true. The syntax arr[b] simply means arr + b where arr is decayed into a pointer to the first element and b is an integer index and normal pointer arithmetic applies. In fact looking purely at the language definition arr[b] is actually equal to b[arr] which even works! (in C at least, I'm not sure if this was maintained in C++) Anyway, any time you use an array it almost always decays immediately into a pointer, but not in every case, as indicated by the word "ordinarily" in the quoted text. A particular example would be templates like for example std::begin.
As for the edit to your question, basically all that std::begin and std::end do in the case of arrays is convert to a pointer. std::begin will simply return the array decayed to a pointer, i.e. a pointer to the first element and std::end will return a pointer to the last + 1 element, or arr + <length>. This is because pointers are perfectly fine iterators, they obey all the rules, (deref with *, next element with ++, prev with --.) This is no accident of course as iterators are modeled after pointers.
One final note; std::begin and std::end don't have to return pointers for array arguments, they can also return some iterator class which basically encapsulates the same pointer or some indexing variable. What they do precisely is up to the standard library implementation that you happen to have, though a good bet is that all existing implementations will return pointers as that is the simplest and most efficient implementation.
3

Here, auto will decay the arr (array type) to a pointer. And both std::begin and std::end can only work for containers or arrays, but not for pointers.

From C++11 standard

§7.1.6.4 auto specifier [dcl.spec.auto]

1 The auto type-specifier signifies that the type of a variable being declared shall be deduced from its initializer or that a function declarator shall include a trailing-return-type.

You code cannot work here as auto cannot deduce array types. Just like:

char a[5];
auto b[5] = a;  // error, a evaluates to a pointer, which does
                // not match the array type

To make it work, just use C++ containers like std::vector:

vector<int> arr = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
Improve this answer

1 Comment

I get that. What I don't get is the text says "when we use an array, the compiler ordinarily converts the array to a pointer." So if arr is converted to pointer, how does begin() and end() work? Is what the text says incorrect, meaning that arrays are not necessarily converted into pointers since begin() and end() works for containers not pointers? Also if there's any way to print arr2 and arr3 using iterators as in specifying the size?
1

std::begin and std::end work with parameters that are C style arrays.

A possible implementation of std::end is:

template<class T, std::size_t sizeOfArray>
constexpr T *end(T (&array)[sizeOfArray])
{
  return &array[sizeOfArray];
}

This way arr is not converted in a pointer when you call std::end(arr) (and the information about the size of the array isn't lost... the function only accepts arrays with exactly sizeOfArray elements as argument).

template<class T>
T *end(T array[])
{
  // ?
}

won't work since T array[] behaves like a flat pointer (T *array), rather than a real array, when used as a function parameter.

auto decays the array arr into a pointer and the trick won't work anymore.

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.