Can we somehow use array[i] instead of *(array+i)? - c++

Question

In C++, when I have to use an array inside some function, I pass the array as an argument and get a pointer pointing to the first element of the array. While it is okay to use, and not much of a hassle to use a pointer, I was wondering if there exists some in-built header file, or any other set of instructions, by which when I want to access the i-th element of the array I can simply write array[i] and it gets read by the compiler as *(array+i)?
It would be great if one exists, since it would make it quite uniform and easy to code, since all the times when I use vectors I can access the i-th element just by vector[i] while in array I have to use it the other way *(array+i).
Also, is there some reason why the developers of C++ chose to return pointers to an array instead of the object itself?

Answer 1

If a is a pointer and i has an integral type, then a[i] is always the same as *(a+i). There is no need to include a header or anything to make it work.

Answer 2

I was wondering if there exists some in-built header file or any other set of instructions by which when I want to access the i-th element of the array I can simply write array[i] and it gets read by the compiler as *(array+i)
No, there is no such header or set of instructions, because it is part of the language.
For a pointer and an integral type, a[i] means *(a+i). This is such a strong statement that:
int base_array[3]={1,2,3}; // an array of 3 elements
int* ptr_array = base_array; // base_array "decays" to a pointer to the first element
std::cout << 2[ptr_array] << "\n"; // huh?!?!
prints 3, because *(2+ptr_array) is 3; ie, it even works backwards.

Answer 3

Can we somehow use array[i] instead of *(array+i)?
Yes, we can. Those expressions are practically identical. The subscript operator is much more readable, so I recommend using that.
I was wondering if there exists some in-built header file
You don't need to include any header.
while in array i have to use it the other way *(array+i)
Just because you can, doesn't mean that you have to. You don't have to use it the other way.
P.S. Besides arrays and vectors, we can also use the subscript operator with a pointer to element of an array.
Also, is there some reason why the developers of C++ chose to return pointers to an array instead of the object itself?
Because sometimes indirection is necessary or useful.

Answer 4

From the C++ 14 Standard (5.2.1 Subscripting)
1 A postfix expression followed by an expression in square brackets is
a postfix expression. One of the expressions shall have the type
“array of T” or “pointer to T” and the other shall have unscoped
enumeration or integral type. The result is of type “T.” The type “T”
shall be a completely-defined object type. The expression E1[E2] is
identical (by definition) to *((E1)+(E2)) [ Note: see 5.3 and 5.7
for details of * and + and 8.3.4 for details of arrays. — end note ],
except that in the case of an array operand, the result is an lvalue
if that operand is an lvalue and an xvalue otherwise.
So these expressions array[i] and *( array + i ) are evaluated the same way whether array in this expressions is an array designator or a pointer to first element of an array,
Moreover these expressions array[i] and i[array] are also evaluated the same way.
Arrays are non-modifianle lvalues so you may not return an array from a function. If to use an array designator in a return statement it will be converted to pointer to its first element. As a result arrays do not have the copy assignment operator.
On the other hand you can return a reference to an array provided that it doesn not have automatic storage duration.
For example
#include <iostream>
const size_t N = 5;
decltype( auto ) f( int ( &a )[N], int init )
{
for ( size_t i = 0; i < N; i++ )
{
a[i] = init++;
}
return a;
}
int main()
{
int a[N];
decltype( auto ) ra = f( a, 0 );
std::cout << sizeof( ra ) << '\n';
for ( const auto &item : ra )
{
std::cout << item << ' ';
}
std::cout << '\n';
return 0;
}
The program output is
20
0 1 2 3 4