#Pointer size in c how to#

Std::cout << 'Element 0 has value: ' << array << ' ' *ptr = 5 // so changing an array element changes the _actual_ array parameter ptr contains a copy of the array's address Consider the following example: #include The fact that arrays decay into pointers when passed to a function explains the underlying reason why changing an array in a function changes the actual array argument passed in. We lightly recommend using the pointer syntax, because it makes it clear that the parameter is being treated as a pointer, not a fixed array, and that certain operations, such as sizeof(), will operate as if the parameter is a pointer. However, in most cases, because the pointer doesn’t know how large the array is, you’ll need to pass in the array size as a separate parameter anyway (strings being an exception because they’re null terminated). Some programmers prefer using the syntax because it makes it clear that the function is expecting an array, not just a pointer to a value. That means the following two function declarations are identical: void printSize(int array) In the above example, C++ implicitly converts parameters using the array syntax () to the pointer syntax (*). PrintSize(array) // the array argument decays into a pointer here Std::cout << sizeof(array) << ' ' // prints the size of a pointer, not the size of the array! array is treated as a pointer here, not a fixed array C++ will implicitly convert parameter array to *array When passing an array as an argument to a function, a fixed array decays into a pointer, and the pointer is passed to the function: Revisiting passing fixed arrays to functionsīack in lesson 10.2 - Arrays (Part II), we mentioned that because copying large arrays can be very expensive, C++ does not copy an array when an array is passed into a function. It’s unlikely you’ll ever need to use this. This pointer also points to the first element of the array, but the type information is different (in the above example, the type of &array is int(*)). Taking the address of the array returns a pointer to the entire array. Taking the address of a pointer yields the memory address of the pointer variable. The second difference occurs when using the address-of operator (&). Std::cout << sizeof(ptr) << ' ' // will print the size of a pointerĪ fixed array knows how long the array it is pointing to is. Std::cout << sizeof(array) << ' ' // will print sizeof(int) * array length

The following program illustrates this: #include When used on a pointer, sizeof returns the size of a memory address (in bytes). When used on a fixed array, sizeof returns the size of the entire array (array length * element size). The primary difference occurs when using the sizeof() operator. These help illustrate that a fixed array and a pointer are not the same. There are a few cases where the difference in typing between fixed arrays and pointers makes a difference. This works because the array decays into a pointer of type int*, and our pointer (also of type int*) has the same type.ĭifferences between pointers and fixed arrays

Std::cout << *ptr << ' ' // will print 9 Std::cout << *array << ' ' // will print 9 Indirection through an array returns the first element (element 0) Std::cout << 'The array decays to a pointer holding address: ' << array << ' ' print the value of the pointer the array decays to Std::cout << 'Element 0 has address: ' << &array << ' ' print address of the array's first element You can see this in the following program: #include

In all but two cases (which we’ll cover below), when a fixed array is used in an expression, the fixed array will decay (be implicitly converted) into a pointer that points to the first element of the array. We know what the values of array, array, array, array, and array are (9, 7, 5, 3, and 1 respectively). To us, the above is an array of 5 integers, but to the compiler, array is a variable of type int.

#Pointer size in c how to#

In a previous lesson, you learned how to define a fixed array: int array // declare a fixed array of 5 integers Pointers and arrays are intrinsically related in C++.