Why are pointers needed in C programming?

Answer 1

pointer is used when we want to retain the change in values between the function calls.

Similarly double pointer is used when we want to retain the change in pointers between the function calls. If you want to modify pointers than you need double pointer to retain the change.

Answer 2

There is no such thing as Double pointers in C, except in case you're referring to the declaration such as: double *p; But still, this should better be called as pointer to double.

Some people incorrectly call pointer-to-pointer as double pointer.

Pointer-to-pointer holds address of another pointer. So it requires double dereferencing to obtain the value object.

Example:

int **p;

This is a declaration of pointer to pointer for int object.

A pointer-to-pointer requires two pointer de-references to obtain an objects value.

This is often used for linked list manipulation and creating multi-dimensional arrays dynamically.

See related links below for some examples:

Answer 3

Pointers are required to both store and refer to memory addresses. All programming languages use pass-by-value semantics which means whenever a value is passed to a function that value must be copied to new memory. For primitive data types this isn't a problem because all primitive data types will fit into a single CPU register. But for complex data types this is highly inefficient. For instance, passing an array of 1 million primitives to a function would be inefficient if every primitive had to be copied individually. It is more efficient to simply pass the address of the array itself. This is achieved by passing a pointer, which is itself a primitive and costs virtually nothing to copy. When we pass pointers to functions we get pass-by-reference semantics.

Languages that do not support a native pointer type can still use pass-by-reference semantics using "smart" pointers known as resource handles. A resource handle is simply an object that refers to a value by its memory address. Thus when we pass a complex object to a function, we're actually copying the resource handle, not the value it refers to. Thus we can have two objects referring to the same value in memory.

C++ also supports a reference data type as well as a pointer data type. References are similar to pointers in that they both refer to a memory address, however a pointer is a variable whereas a reference is not. That is, we can store any memory address in a pointer (including nullptr) and thus refer to any object in memory. But a reference is merely an alternative name (an alias) for an existing object; it can never be null and must always refer to the same object throughout its scope. A pointer is a variable in its own right, but a reference is not. As such, a pointer requires memory (storage) of its own thus we can refer to pointers using a pointer-to-pointer type. This adds an additional level of indirection but makes it possible to create arrays of pointers and thus create multi-dimensional arrays in non-contiguous memory. An array of string objects is an example of this; the strings themselves need not be the same length thus we can make better use of memory at the cost of one additional level of indirection. With an array of fixed-length strings we'd get faster access to the strings but we may waste more memory simply to cater for the largest string in the array.

Answer 4

Double pointers are better known as pointer-to-pointer types. You use pointers to store the memory address of an object but when the object is itself a pointer, you need to use a pointer-to-pointer in instead.

Pointer-to-pointer types are typically used when passing pointers into functions. Pointers allow you to pass objects to functions by reference but the pointer itself is passed by value. If you want to pass the pointer by reference, you need to pass a pointer-to-pointer.

Answer 5

Pointer is a variable which points to the address of another variable. Pointers come handy when we are left with no choices such as calling a function using "pass by reference" method, using memory allocated dynamically etc...

Answer 6

declaration of a double pointer:

int **pInt;

allocating memory for a double pointer:

pInt = malloc(sizeof(*pInt));

*pInt = malloc(sizeof(*pInt));

Answer 7

one is the pointer to apointer where changing it a pointter.