Possible Duplicate:
Is array name a pointer in C?
Are arrays and pointers implemented differently? I have come across this question because , in both the cases we access elements from the starting address of an element.So , there should be close relation between them . Please explain the exact relation between them . Thanks.
Don't know about C++. For C, the c-faq answers much better than I ever could.
Small snippet from c-faq:
6.3 So what is meant by the ``equivalence of pointers and arrays'' in C?
[...]
Specifically, the cornerstone of the equivalence is this key definition:
A reference to an object of type array-of-T which appears in an expression decays (with three exceptions) into a pointer to its first element; the type of the resultant pointer is pointer-to-T.
[...]
In C++ according to the C++ Standard 4.2:
An lvalue or rvalue of type “array of N T” or “array of unknown bound of T” can be converted to an rvalue of type “pointer to T.” The result is a pointer to the first element of the array.
Few points of differences :
An array name is a pointer to the first element.
It is a constant pointer.
you can add an integer to a pointer or subtract an integer from pointer, where as in case of array you use subscript operator.
With a few exceptions they can be treated the same way. Given:
int arr[16];
int *pArr = (int *)malloc(16 * sizeof(int));
int ** while &arr gives you the address of the array data int (*)[16].In C++ (and in C too I think), an array is not a pointer and that can be proven in the following way.
#include <iostream>
int main()
{
char arr[1000];
std::cout << sizeof arr;
}
if arr were a pointer this program would print sizeof (char*) which is typically 4. But it prints 1000.
another proof:
template <class T>
void f(T& obj)
{
T x = obj; //this will fail to compile if T is an array type
}
int main()
{
int a[30] = {};
int* p = 0;
f(p); //OK
f(a); //results in compile error. Remember f takes by ref therefore needs lvalue and no conversion applies
}
Formally, an array is converted to a pointer to its first element in lvalue-to-rvalue conversions, that is when an lvalue of array type is given in a context when an rvalue is expected, the array is converted to a pointer to its first element.
Also, a function declared to take an array by value is equivant to function taking a pointer, that is
void f(int a[]);
void f(int a[10]);
void f(int* a);
are three equivalent declarations. HTH
No, they are not implemented differently. Both find elements with the same calculation: a[i] is at address a + i*sizeof(a[0]), also p[i] is at address p + i*sizeof(p[0]).
But, they are treated differently by the type system. C++ has typing information on arrays which can be seen through the sizeof operator (like C), template inference, function overloading, RTTI, and so on. Basically anywhere in the language that type information is used, it is possible for pointers and arrays to behave differently.
There are many many examples in C++ where two different language concepts have the same implementation. Just a few: arrays vs pointers, pointers vs references, virtual functions vs function pointers, iterators vs pointers, for loops vs while loops, exceptions vs longjmp
In every case, there's a different syntax and a different way of thinking about the two concepts, but they result in the same machine code in the end.
Let's get the important stuff out of the way first: arrays are not pointers. Array types and pointer types are completely different things and are treated differently by the compiler.
Where the confusion arises is from how C treats array expressions; except when it is the operand of the sizeof or the unary & operator, or if it is a string literal being used to initialize another array, an array expression will have its type implicitly converted from "N-element array of T" to "pointer to T", and its value will be a pointer to the first element in the array.
Let's look at the following declarations:
int arr[10] = {0,1,2,3,4,5,6,7,8,9};
int *parr = arr;
arr is a 10-element array of int; it refers to a contiguous block of memory large enough to store 10 int values. The expression arr in the second declaration is of array type, but since it is not the operand of & or sizeof and it isn't a string literal, the type of the expression becomes "pointer to int", and the value is the address of the first element, or &arr[0].
parr is a pointer to int; it refers to a block of memory large enough to hold the address of a single int object. It is initialized to point to the first element in arr as explained above.
Here's a hypothetical memory map showing the relationship between the two (assuming 16-bit ints and 32-bit addresses):
Object Address 0x00 0x01 0x02 0x03
------ ------- ----------------------
arr 0x10008000 0x00 0x00 0x00 0x01
0x10008004 0x00 0x02 0x00 0x03
0x10008008 0x00 0x04 0x00 0x05
0x1000800c 0x00 0x06 0x00 0x07
0x10008010 0x00 0x08 0x00 0x09
parr 0x10008014 0x10 0x00 0x80 0x00
The types matter for things like sizeof and &; sizeof arr == 10 * sizeof (int), which in this case is 20, whereas sizeof parr == sizeof (int *), which in this case is 4. Similarly, the type of the expression &arr is int (*)[10], or a pointer to a 10-element array of int, whereas the type of &parr is int **, or pointer to pointer to int.
Note that the expressions arr and &arr will yield the same value (the address of the first element in arr), but the types of the expressions are different (int * and int (*)[10], respectively). This makes a difference when using pointer arithmetic. For example, given:
int arr[10] = {0,1,2,3,4,5,6,7,8,9};
int *p = arr;
int (*ap)[10] = &arr;
printf("before: arr = %p, p = %p, ap = %p\n", (void *) arr, (void *) p, (void *) ap);
p++;
ap++;
printf("after: arr = %p, p = %p, ap = %p\n", (void *) arr, (void *) p, (void *) ap);
the "before" line should print the same values for all three expressions (in our hypothetical map, 0x10008000). The "after" line should show three different values: 0x10008000, 0x10008002 (base plus sizeof (int)), and 0x10008014 (base plus sizeof (int [10])).
Now let's go back to the second paragraph above: array expressions are converted to pointer types in most circumstances. Let's look at the subscript expression arr[i]. Since the expression arr is not appearing as an operand of either sizeof or &, and since it is not a string literal being used to initialize another array, its type is converted from "10-element array of int" to "pointer to int", and the subscript operation is being applied to this pointer value. Indeed, when you look at the C language definition, you see the following language:
6.5.2.1 Array subscripting
...
2 A postfix expression followed by an expression in square brackets [] is a subscripted designation of an element of an array object. The definition of the subscript operator [] is that E1[E2] is identical to (*((E1)+(E2))). Because of the conversion rules that apply to the binary + operator, if E1 is an array object (equivalently, a pointer to the initial element of an array object) and E2 is an integer, E1[E2] designates the E2-th element of E1 (counting from zero).
In practical terms, this means you can apply the subscript operator to a pointer object as though it were an array. This is why code like
int foo(int *p, size_t size)
{
int sum = 0;
int i;
for (i = 0; i < size; i++)
{
sum += p[i];
}
return sum;
}
int main(void)
{
int arr[10] = {0,1,2,3,4,5,6,7,8,9};
int result = foo(arr, sizeof arr / sizeof arr[0]);
...
}
works the way it does. main is dealing with an array of int, whereas foo is dealing with a pointer to int, yet both are able to use the subscript operator as though they were both dealing with an array type.
It also means array subscripting is commutative: assuming a is an array expression and i is an integer expression, a[i] and i[a] are both valid expressions, and both will yield the same value.
The biggest point of confusion between arrays and pointers comes from K&R's decision to make function parameters which are declared as being array type behave as though they were declared as pointers. The declarations
void foo(int a[]);and
void foo(int *a);are equivalent, as is (so far as I can tell)
void foo(int a[5]);though I'm not positive a compiler would be required to accept a reference to a[6] within the latter function. In other contexts, an array declaration allocates space for the indicated number of elements. Note that given:
typedef int foo[1];
any declaration of a type foo will allocate space for one element, but any attempt to pass foo as a function parameter will instead pass the address. Something of a useful trick I learned in studying a va_list implementation.
In C++ array type has a "size attribute", so for
T a[10];
T b[20];
a and b has different types.
This allows to use code like this
template<typename T, size_t N>
void foo(T (&a)[N])
{
...
}