How are pointer different from other variables?

Answer 1

A pointer variable is a variable that contains the memory location of another variable or an array (or anything else in memory). Effectively, it points to another memory location.

For standard variables, you define a type, assign a value to that variable or read the value from it, and you can also read the memory location (&n = memory location of n) of the variable.

For pointers, you can point them to any variable, even another pointer, and you can get the value of the variable it points to (*p), the location of that variable in memory (p), or the address in memory of the pointer itself (&p).

Consider:

long n = 65;

long *p;

p = &n;

Results:

Type | Name | Location | Value

long n 0xA3FF 65

long * p 0x31DF 0xA3FF

So p points to n. Now,

n = 65

&n = 0xA3FF

p = 0xA3FF

*p = 65

&p = 0x31DF

You may find yourself having to use typecasts frequently when using pointers.

Pointers are useful when passing data to functions.

For instance, consider the following function:

void add(int a, int b, int c) { c = a + b; }

The problem here is that the computer copies each variable into a new memory location before passing them to the function as local variables. This function effectively does nothing. However, if you change the function to:

void add(int a, int b, int *c) { c = a + b; }

and call the function by passing in the location of the variable to the function:

add(a,b,&c);

then you can modify the variable itself.

Pointers are also good for working with arrays:

char *c = "Hello World";

int i=0;

while (c[i] != 0x00) { cout << c[i]; c++ } //print one letter at a time.

Answer 2

A pointer type differs from all other types in that it is used specifically for the purpose of storing a memory address and for permitting indirect access to the value stored at that memory address. When we store a memory address, we are said to be pointing at that memory address. When we indirectly access the value stored at that memory address, we are said to be dereferencing the pointer. We can also say that a pointer holds a reference to the object stored at the memory address it points to.

Pointers may only store memory addresses where the memory holds a value of the same type as the pointer, or is of a type that is co-variant with the pointer's type. Where the type is unknown we can use a void pointer, however this is best avoided wherever possible.

A pointer may be constant or variable. When it is variable, we can assign any appropriate memory address to the pointer at any time. When it is constant, we must assign an address at the point of instantiation and cannot change that address while the pointer is in scope; it must always point at the same memory. Note that the constness of the pointer does not affect the constness of the object being pointed at. However, if the object being pointed at is of a constant type, then the pointer must be a pointer to that constant type, regardless of whether the pointer itself is variable or constant. Thus we can point at a memory address in four different ways: a variable pointer to a variable type; a variable pointer to a constant type; a constant pointer to a variable type and; a constant pointer to a constant type. We define both aspects when we instantiate the pointer.

Answer 3

In C language a pointer is a variable that stores the address of another variable. In other words, pointer is a variable which points or references to another one variable or a memory location. The syntax for declaring a pointer variable is as follows.

type * pointer_variable_name

The character * tells the compiler that the variable declared is a pointer. The type specified the type of data stored in the location pointed by the variable.

The data stored in the location pointed by the pointer can be retrieved by a dereference operation.

eg:

int *a; // a is pointer of type integer

int b=10; // b is an integer with value 10

a = &b; // assigning a pointee - & will take the address of b

printf("%p %p %d %d",a,&b,*a,b); // Output will be in the following order

(1) the address of b

(2) address of b

(3) value of b - through pointer dereferencing

(4) value of b

Important: A pointer must be initialized or assigned before using it. By default all the pointers are bad pointers, which means the pointer is uninitialized. A dereference operation in a bad pointer may cause catastrophic impact on the system, since you might be accessing some unknown memory location.

In addition (as this question is also under the Java Programming section), it should be noted that Java DOES NOT support pointers. That is, the pointer concept does not exist in Java.

Answer 4

Pointer is a variable which store address of an other variable. To declare a pointer variable <syntax>:

<data-type> *<variable-name>;

example:

int *x;

now x will store an address. to find the address of any variable we use '&' in c.

example:

int y;

then address of y is &y;

but now x will store only address :

x= &y;

here x= address of variable and *x = value at the variable.

Answer 5

By assigning an address to them. All pointers must be initialised with the nullptr value (zero) if you cannot initialise with a valid address. If the address falls from scope, you must nullify the pointer.

Ideally you should avoid using raw pointers and use resource handles instead (smart pointers). However, C is not an object oriented programming language so raw pointers are unavoidable. The onus is therefore upon the programmer to ensure all pointers are initialised and nullified whenever they are no longer required.

Answer 6

Pointer variables are initialised by assigning an address to them. If you have no valid address, assign null (the zero address).

Answer 7

With a *

For example:

int *pointerToInt;

Answer 8

these are the memory locations i.e. addresses. try printing the content of pointer u'll get the memory location where they are stored. :-)

Answer 9

Use the pointer operator (*) immediately after the type.

Answer 10

normal variable contains the value of variable (ex.int or float) whereas pointer variable contains the address of another variable