Practically speaking what is the difference between arrays and pointers

The expression, matrix[0] , returns the address of the first element of the first row of the array. This address is the address of an array of integers. Thus, when we add one to it, the size of a single integer is added to it, giving us the second element.

The output will be and 2. We can graphically depict the array as illustrated in Figure Two-dimensional array notation can be interpreted as shown in Figure Passing a multidimensional array to a function can be confusing, especially when pointer notation is used. By shape, we are referring to the number and size of its dimensions.

Otherwise, the compiler is unable to use subscripts. To pass the matrix array, use either:. In both versions the number of columns is specified. This is needed because the compiler needs to know the number of elements in each row. If this information is not passed, then it is unable to evaluate expressions such as arr[0][3] as explained in the section Pointers and Multidimensional Arrays.

In the first version, the expression arr[] is an implicit declaration of a pointer to an array. While it will not generate a syntax error, the array passed is assumed to be a five-element array of pointers to integers. Using a One-Dimensional Array of Pointers discusses arrays of pointers. The function does not allocate memory for the array. Only the address is passed. You may encounter a function declared as follows.

It is passed a single pointer and the number of rows and columns:. To invoke the function, we can use the following:. This is not possible because the pointer is not declared as a two-dimensional array.

However, it is possible to use array notation as shown below. While using matrix will execute correctly, a warning will be generated, indicating incompatible pointer types. When passing an array with more than two dimensions, all but the size of the first dimension need to be specified. The following demonstrates a function written to display a three-dimensional array. The last two dimensions are specified in the declaration:. The expression arr3d[1][0] refers to the second row, first column of the array and is a pointer to a one-dimensional array of size 5.

Several issues are involved with dynamically allocating memory for a two-dimensional array, including:. However, when we use a function such as malloc to create a two-dimensional array, there are variations in how memory can be allocated. Whether or not it is contiguous can affect other operations, such as copying a block of memory.

Multiple copies may be required if the memory is not contiguous. The following illustrates one way of allocating a two-dimensional array where the allocated memory is not guaranteed to be contiguous.

Since separate malloc calls were used, the allocated memory is not guaranteed to be contiguous. This is illustrated in Figure It may well be contiguous. We will present two approaches for allocating contiguous memory for a two-dimensional array.

The second technique allocates all of the memory at once. The first technique is illustrated in the following sequence. The first malloc allocates an array of pointers to integers. Each element will be used to hold a pointer to a row. This is the block allocated at address in Figure The second malloc allocates memory for all of the elements of the array at location In the for loop, each element of the first array is assigned a portion of the memory allocated by the second m alloc :.

In the second technique shown below, all of the memory for the array is allocated at one time:. This allocation is illustrated in Figure When the array is referenced later in code, array subscripts cannot be used.

Instead, indexes into the array need to be calculated manually, as illustrated in the following code sequence. Each array element is initialized to the product of its indexes:. Array subscripts cannot be used because we have lost the shape information needed by the compiler to permit subscripts. This concept is explained in the section Passing a Multidimensional Array. This approach has limited use in the real world, but it does illustrate the relationship between the concept of a two-dimensional array and the one-dimensional nature of main memory.

The more convenient two-dimensional array notation makes this mapping transparent and easier to use. We have demonstrated two general approaches for allocating contiguous memory for a two-dimensional array. The approach to use depends on the needs of the application. A jagged array is a two-dimensional array possessing a different number of columns for each row. Conceptually, this is illustrated in Figure , where the array has three rows with a varying number of columns per row.

A compound literal is a C construct that consists of what appears to be a cast operator followed by an initializer list enclosed in braces. An example of a compound literal follows for both a constant integer and an array of integers. These would be used as part of a declaration:. In the following declaration, we create the array arr1 by declaring it as an array of pointers to an integer and using a block statement of compound literals to initialize it:.

This array has three rows and three columns. Figure depicts how memory is laid out for this array. This declaration can be modified slightly to create a jagged array as depicted in Figure The array declaration follows:. We used three compound literals to declare the jagged array. The next sequence will display the array to verify its creation. The sequence required three for loops because each row had a different number of columns:.

This made it somewhat easier to see and understand. However, pointer notation would have worked as well. Compound literals are useful in creating jagged arrays. However, accessing elements of a jagged array can be awkward, as demonstrated with the previous three for loops.

This example can be simplified if a separate array is used to maintain the size of each column. While you can create jagged arrays in C, it may not be worth the effort. We started with a quick review of arrays and then examined the similarities and differences between array and pointer notation.

These type of functions provide more flexibility than afforded by traditional array declaration. We saw how we can use the realloc function to change the amount of memory allocated for an array.

Dynamically allocating memory for an array can present challenges. In the case with two or more dimensional arrays, we have to be careful to make sure the array is allocated in contiguous memory. We also explored the problems that can occur when passing and returning arrays. We also examined how to create jagged arrays in C. Skip to main content. Start your free trial. Chapter 4. Pointers and Arrays. Quick Review of Arrays. Note Arrays have a fixed size. One-Dimensional Arrays. Two-Dimensional Arrays.

Multidimensional Arrays. Pointer Notation and Arrays. Table Differences Between Arrays and Pointers. Using malloc to Create a One-Dimensional Array. Using the realloc Function to Resize an Array. Passing a One-Dimensional Array. Using Array Notation. Warning A common mistake is to use the sizeof operator with the array in order to determine its number of elements, as shown below. Using Pointer Notation. Using a One-Dimensional Array of Pointers. Using an Array of Function Pointers , where we use an array of function pointers; How Memory Is Allocated for a Structure , where an array of structures is used; and Passing Arguments to an Application , where the argv array is handled.

Array of pointers expressions. Pointers and Multidimensional Arrays. Passing a Multidimensional Array. Dynamically Allocating a Two-Dimensional Array. Whether the array elements need to be contiguous Whether the array is jagged. Note Whether or not it is contiguous can affect other operations, such as copying a block of memory. Allocating Potentially Noncontiguous Memory. Allocating Contiguous Memory. Jagged Arrays and Pointers.

The size of the initial buffer and the amount it will be incremented by when the buffer needs to be enlarged. Asked 7 years ago. Active 7 years ago. Viewed times. But this StackOverflow question has a highly-upvoted comment that says Arrays are not pointers.

Stop telling people that. Community Bot 1 1 1 silver badge. What part of this question is not answered by stackoverflow. This question is more generally conceptual.

Arrays are not pointers, but you can index pointers as if they were arrays. Arrays also decay to pointers readily. Besides that, function parameters that look like arrays are really pointers. So there are plenty of sources of confusion. All or most of this comes from C. Consider that the type of an array includes the number of elements, and that the size of that type accounts for the total space.

Arrays can decay to pointers. But you can also pass arrays by reference to a function. In this case, there is no decay to pointer. You can also pass pointers to arrays.

In both cases, the size information is kept. Arrays function as pointers when passed to functions that expect pointers. Show 7 more comments. Active Oldest Votes. There is a lot of bad writing out there.

An object is any region of allocated storage. Yes this is a slightly circular definition! Each byte of allocated storage has an address which is a token usually representible as a simple number that can be used to find that byte in memory. The addresses of any bytes within an object must be sequential. The name x only exists during the compilation stage of a program.

At runtime there can be int objects allocated that never had a name; and there can be other int objects with one or more names during compilation. All of this applies to objects of any other type, not just int An array is an object which consists of many adjacent sub-objects of the same type A pointer is an object which serves as a token identifying where another object can be found.

The equivalence is that the same processing can be used for both of the following: Find Nth element of an array Find Nth object in memory after the one we're looking at and furthermore, those concepts can be both expressed using the same syntax. M k 20 20 gold badges silver badges bronze badges.

Add a comment. Let's start by simply defining a pointer and an array. A pointer to a type T points to a memory space which holds at least one T assuming non-null. An array is a memory space that holds multiple Ts. Puppy Puppy k 34 34 gold badges silver badges bronze badges. A pointer to a type need not point to at least one object of the type.

To add to the confusion, a pointer to an array is a different thing than a pointer to an element of an array. Deduplicator: I don't recall the exact Standard wording, but simply forming some kinds of invalid pointers is UB right away, even if you don't de-ref them, IIRC.

All the legal aliasing stuff just confuses what "object" and "type" actually mean in this respect. Pointer-to-array types are interchangable as long as you don't index them :P — Puppy. An array is a single, preallocated chunk of contiguous elements all of the same type , fixed in size and location. A pointer is a reference to any data element of a particular type anywhere.

A pointer must be assigned to point to space allocated elsewhere, but it can be reassigned and the space, if derived from malloc, can be resized at any time. A pointer can point to an array, and can simulate along with malloc a dynamically allocated array, but a pointer is a much more general data structure. Due to the so-called equivalence of arrays and pointers, arrays and pointers often seem interchangeable, and in particular a pointer to a block of memory assigned by malloc is frequently treated and can be referenced using [] exactly as if it were a true array.

Continued on next question