Math and Arithmetic
C Programming
C++ Programming
The Difference Between

# What is the difference between array of pointers and pointer to an array?

An array of pointers is that for eg if we have array of 10 int pointers ie int *a then each element that which is stored in array are pointed by pointers. here we will have ten pointers. In pointer to an array for eg int(*a) here all the elements that is all the ten elements are pointed by a single pointer.

🙏
0
🤨
0
😮
0
😂
0

## Related Questions

There is no such thing as an "array to pointer." What you might be asking is "array of pointers." An array of pointers is just that, an array in which the variables are pointers. In C this would be an array of pointer variables that are each 4 bytes in size. It is declared like this: int *pointers; A pointer to an array is a pointer that points to the whole array. For example, in C if you have int numbers; int (*pointerToArray) = numbers + 2; pointerToArray points to the third element of numbers, which is itself an array.

There is a difference: a pointer is a number that literally points to a place in memory. Arrays are groupings of a type. There is a close relationship between pointers and arrays, however: every expression with arrays (example: array[i]) can be expressed with pointers (example: *(array + i)), because for the computer, an array is just a list of pointers to the type of the array.

array and pointer both are derived datatypes..

Arrays are implemented as pointers in c.

A pointer into an array of elements of type E is a pointer to a single element of type E:typedef ..... E;E array;E* const pointer = &array; // points to the 19th element inside 'array'An array of pointers is an array whose elements are pointers:typedef .... E;E* array;E** const pointer = &array; // points to the 19th pointer within 'array'Referencing the name of the array variable without use of the index operator itself is a constant pointer to its first element. Therefore, the following if-clause is always true:typedef .... E;E array;if (array &array[N]) { // ALWAYS true ...}

pointer is use to hold address of another variable whereas array is a collection of elements of similar datatype

--> Array is a collection of same kind of data.--> Pointer is a memory location where the data stored in the memory

Because of pointers and that all arrays are really pointers. A pointer something like *pointer can also be written as pointer and *(pointer + 1) can also be written as pointer

A pointer is a variable that may contain a memory address, or NULL (zero). An array is collection of data, usually residing in a contiguous block of memory, where every element is accessed as an offset from the beginning of the array.

arrays are the reserved sets of variables, which are supposed to store the similar data. pointers are the special variables which store the address of other variables.

If the array is static you can simply point at the first element. For dynamic arrays you can allocate a contiguous block to a single pointer which can then be subdivided using a one-dimensional array of pointer to pointers, each of which points to a one-dimensional array of pointers, each of which points to a separate object within the array. For extremely large arrays, however, it is better to split the elements into separate one-dimensional arrays, by creating a one-dimensional array of pointer to pointers first, then allocating each of those pointers to a separate one-dimensional array of pointers, each of which points to a separate one-dimensional array of objects. Either way, you must destroy all the individual arrays in the reverse order of creation.

Yes. For example, argv parameter of function mainis a pointer to an array of pointers to characters.

An array of pointers is exactly what it sounds like - one or more pointers arranged in order in memory, accessible through a common base name and indexed as needed. Philosophically, there is no difference between an array of pointers and an array of objects...int a; // 10 integers, named a, a, a, ..., aint *b; // 10 pointers to int, named b, b, b, ..., bIf you initialize the array of pointers...int i;for (i = 0; i ... then *b would be the same as a, etc.

You point at the array the same way you would with an array of any pointer type, by using an additional level of indirection than is employed by the pointers in the array itself. In this case, the array contains pointer-to-function data types (with one level of indirection), thus you must use a pointer-to-pointer-to-function data type (with two levels of indirection) in order to point at the array itself. Had the array contained pointer-to-pointer-to-function data types (where each pointer points to a separate array of pointer-to-function data types), then you'd use three levels of indirection, and so on. You increase the level of indirection by placing an additional asterisk before the pointer's name when you declare the pointer. That is, one asterisk per level.

An array is a collection of objects of similar data type ,whereas pointers are variable which is used to hold the address of the other variable.

An array of pointers is exactly what is says on the tin - an array which contains pointers to memory addresses.If you were to create an array of ten integers like this:int array;This would create an array which you could directly access from the stack (memory allocated to the program by the Operating System).However, if you wanted to create an array of pointers to integers, allowing for a more efficient use of memory, you could do this:int *array = new int;This dynamically allocates an array of 10 pointers to integers.Comment:This example is hardly an efficient use of memory. Not only are you declaring 10 integers, you are declaring a pointer, which uses slightly more memory than would otherwise be required by the first example. An array of pointers is more useful when the memory they point to is non-contiguous and the number of elements is dynamic rather than static. Even dynamic multi-dimensional arrays can be allocated in contiguous space and simple pointer arithmetic can be used to access any element, thus only one pointer is required for the entire array rather than separate arrays of pointers and pointer-to-pointer arrays for each dimension. While pointer arrays can often improve performance, it is always at the expense of memory consumption.

An array is a contiguous block of memory containing one or more elements of the same type. The array identifier is a reference to that block of memory. References do not require any memory other than the memory they reference. References are not variables -- they are merely aliases for memory addresses. A pointer is a variable that can store any reference and provides indirect access to that reference. Pointers can be used to allocate arrays dynamically, which means memory is required not only for the array, but also for the pointer to store the starting memory address of the array. Once allocated, the array can be referenced directly, but the pointer is still required in order to release the memory allocation when it is no longer required. Arrays employ pointer arithmetic to locate individual elements by their zero-based index, which is essentially an offset from the reference multiplied by the size of the element type. However arrays and pointers are not the same from a programming standpoint. Your compiler may well implement references as pointers, but that is only of concern to compiler authors, not programmers. Two-dimensional dynamic arrays make use of a pointer-to-pointer variable to point to a one-dimensional array of pointers, each of which points to a one-dimensional array of the actual elements. A three-dimensional array employs a pointer-to-pointer-to-pointer to point to a one-dimensional array of pointer-to-pointer variables, each of which points to a two-dimensional array. And so on. Static arrays use less memory as there is no need to maintain arrays of pointers, but static arrays are only useful when the number of elements and dimensions are known at compile time. At runtime, arrays of pointers are required over and above the array elements themselves, in order to both allocate and deallocate the memory, as well as obtain references to the elements in the array. Pointers also have uses beyond that of dynamic arrays, including allocating any type of memory of any size, and pointing at functions which can then be passed as arguments to other functions.

A pointer is normally considered an atomic data type. Therefore, a pointer cannot "be indexed like an array" in that it is not possible to access portions of a pointer through an index. However, a pointer can point to data which can be accessed through pointer operations as well as through index operations. Further, multiple pointers can be arranged in an array of pointers, and each individual pointer within that array of pointers can be reached through its array index. Example 1: an array of pointers const char* const array_of_pointers[] = { "Hello, World", "Hello, Venus", "Hello, Mars" }; In this example, each of array_of_pointers, array_of_pointers or array_of_pointers evaluates to one pointer, selected with the array index 0..2. Example 2: access to data through pointer using an array-style index void example(char* const text) { *text = 'a'; // set first character pointed to to 'a' *(text+1) = 'b'; // second char becomes 'b' // the following are equivalent to the above, but use index notation: text = 'a'; text = 'b'; } Key to example 2 is the declaration of the pointer as a constant pointer.

a pointer is a variable that contains memory location of another variable.the value u assign to the pointers are memory address of other variable.

A hard question to answer. If you do not understand the concept of array and the concept of pointer nothing I can tell you will be meaningful. Learn about arrays and pointers and the answer will be self evident.

Yes. More specifically, they can be used to represent a dynamic multi-dimensional array. As most people know, for a one-dimensional dynamic array, you simply need a pointer to the first element in the array, where each element contains an object of the same type as the pointer. The pointer can be passed around functions just as if it were a static array, the only difference being the requirement to pass the upper bound of the array as well as the array itself. For a two-dimensional array, you need a pointer-to-pointer which points to the first element of a one-dimensional pointer array, where each pointer in that array points to a one-dimensional array of objects. The pointer-to-pointer must be the same type as the pointers and the objects. For a three-dimensional array you need a pointer-to-pointer-to-pointer. And so on. Each additional dimension simply adds a new level of indirection, and a new level of one-dimensional pointer arrays. Of course multi-dimensional arrays are only useful if every dimension is fully utilised and doesn't require too much in the way of resizing. If that is not the case, then you may get more efficient memory consumption from a vector of vectors (of vectors), which allows dynamic resizing at every level without having to copy existing elements. The downside is you lose the random access provided by the array.

There are no array operations in C. Arrays implicitly convert to pointers, thus any operation you might attempt upon an array you would actually perform on a pointer.

A pointer is a variable like any other. As such, it has memory allocated to it. It is similar to an int in that they both store a value in their memory location. However, whereas an int value is interpreted as a whole number, a pointer's value is interpreted as a memory address. The pointer is said to "point to" the memory address it contains. The type of the pointer determines the type of the variable stored at that memory address. the following is a declaration of a pointer to an integer initialised with the value zero: int * p = new int(0); A pointer to a pointer is no different to an ordinary pointer, except the memory address it points to is that of another pointer. The following is an example of a pointer that points to the pointer we've just declared. int ** pp = p; Pointer-to-pointer variables are typically used whenever you need to pass a pointer by reference. All pointers are passed by value, so the memory address they contain is passed, not the pointer variable itself. To pass the pointer itself, you must pass a pointer to the pointer, which passes the memory address of the pointer. This then makes it possible to change the memory address stored in that pointer. Pointer-to-pointer variables are also used when declaring dynamic, multi-dimensional arrays. For instance, a 2-dimensional array requires a pointer-to-pointer to reference the array itself. This pointer points to a 1-dimensional array of pointers, each of which points to a 1-dimensional array of the actual variables in the array. Unlike a static multi-dimensional array, where the entire array occupies contiguous memory, a dynamic multi-dimensional array may not reside in contiguous memory. Pointer-to-pointer can be extended further to accommodate 3-dimensional arrays, and above. A 3D array requires a pointer-to-pointer-to-pointer, which points to a 1-dimensional array of pointer-to-pointer, each of which references a 2D array, as previously outlined.

When a array is passed to a function, the array is internally changed to a 'pointer'. And pointers are always passed by reference. Hence the answer to the question.

###### Computer ProgrammingSoftware and Applications (non-game)C ProgrammingJava ProgrammingHumor & Amusement Copyright © 2021 Multiply Media, LLC. All Rights Reserved. The material on this site can not be reproduced, distributed, transmitted, cached or otherwise used, except with prior written permission of Multiply.