* If you’re here then probably you are beginner and trying to quickly understand the topic. So here everything is defined very simple in points so you can quickly understand everything.
- A variable is something that contains different values at different times.
- In a Program, variable has;
- Value (For this we use assignment “=” Operator).
- It creates a variable reserves appropriate space in memory.
- An int is used to store an integer in reserved memory.
- A char is used to store a character in its reserved memory.
- Char x; // reserves 1 bytes in memory.
- Int y; // reserves 2 byte in memory.
- Float z; // reserves 4 byte in memory.
- Each memory location has two components contents and an address.
- Contents are values stored on that memory location &
- Address is offset from starting memory location.
- It is only the schematic representation. Actual contents of memory are a combination of binary 0’s & 1’s.
- So according to figure;
In case of y binary equivalent of 10 will be stored
In case of x binary equivalent of ASCII code of ‘a’ will be stored.
* The Concept of Points is stick with comparatively low level languages such as C/C++.
- Pointers are also the variables but on the replacement of any value, they store the address of some memory location.
- Its means that;
- The contents of a pointer variable are the address of some other memory location.
- Its means that;
- Declaration of Pointers:
- Int * myptr;
- Read as:
- “ myptr is Pointer to an Integer “
- int* pi; // creates a pointer to int
- char* pc; // creates a pointer to char
- double * x…
Similar to simple variables memory location reserved for pointer will have two components
- Its address
Here, The contents of a pointer are the address of another memory location.
- Unary Operator [ & ]:
- Use to returns the address of any variable
So, According to figure;
- int *p; // pointer p is created at address 150 ( where p has some garbage value )
- int x=43; // an int x with contents 43 is created at address 290.
- p=&x ; // & is a unary operator returns the address of x i.e. 290
// now the contents of p is 290
// i.e. p points to 290 and 290 is a pointer of p
- cout<<x; // print value of x i.e. 43
- cout<<p; // print value of p i.e. 290
Memory of Pointers:
The number of bytes a pointer takes in memory depends on the operating system environment;
- In 16-bit environment it takes 16 bit or 2 bytes.
- In 32 bit environment it takes 4 bytes.
- In 64-bit environment it takes 8 bytes and so on.
All pointers are same as for as their contents are concerned the contents of every pointer is the address of some other memory location.
- “int*” stores address of a memory location.
- char* also stores address of a memory location.
- long* also stores the address of a memory location.
The type of a pointer tells the compiler the type of contents of memory location pointed by pointer.
Like; int* x; tells the compilers that the memory location pointed by x will have an integer value.
- This information is useful in a variety of ways including indirection and pointer arithmetic’s.
Note: pointer cannot de-reference until assigned a value.
Indirection is used to access the value at memory location pointed by the pointer, also called dereferencing.
- Indirection can be performed while accessing a variable, put “a * “ before variable name.
cout<<*p; // will print the contents of memory location pointed by p.
p=&x ; //assigning address of x to pointer p
cout<<x; // print value of x i.e. 43
cout<<&x; // print address of x i.e. 290
cout<<p; // print value of p i.e. 290
cout<<&p; // print address of p itself i.e. 150
cout<<*p; // print value of memory location whose address is stored in p. i.e. 43
- At indirection the type of value pointed by the pointer tells the compiler the number of bytes to deference. In case of int it will pick 2 bytes and in case of char it will pick 1 byte.
- As the pointer just stores the starting address so it’s compulsory to tell compiler number of bytes to dereference.
int x = 43;
pi = &x ;
char * pc;
char y = ‘a’;
pc = &y
cout << *pi; // 2 bytes will dereference ( i.e. 43) as pi is an int pointer
cout << *pc; //only 1 bytes will dereference (i.e. a)as pc is a char pointer
- Pointer arithmetic is a special type of arithmetic.
- The pointer arithmetic are dependent on pointer type;
p++; // adds 2-bytes to the pointer address, since type is int.
pd++; // adds 4-bytes to the pointer address, since type is long.
- Similar case with other basic & user defined data types as the compiler knows how many bytes to go forward.
- Following are the allowed pointer operations;
- Subtraction of pointers results in the number of elements between the pointers. When two pointers subtract then it shows how many units the two pointer of their data type.
- Addition of integer values in pointers
- Add or subtract pointers with an integer value
- “Adding two pointers are not allowed”
- Example: (C++)
int* p1; // simple way of defining pointers
p2 = &x;
p1 = p2; // assign value of p2 into p1
p2 = p2 + 5; // adds 10 bytes in p1
cout << (p2 – p1); // prints the number of
// elements between the //two pointers, which is 5 //p3 = p2 + p1; is illegal operation
Pointer Variable & Constant:
- By Default, Pointers are variables.
int * yptr;
yptr = y;
yptr++ ; // Now, memory address will be increment by depend upon its data type. Here it is increment by 4-bytes.
* yptr++; // Now, it will increment the value of yptr.
yptr = y
// is same as;
yptr = &y;
yptr = &y;
- If we can write on the memory address then it will not happened.
Int x = 10;
Int * yptr;
yptr = &x;
* yptr += 3; //Here, the value of x increment by 3
ypt += 3; //Here, the address of yptr increment by “12 . (In 16-bit environment)
- Similar with Decrement.
- By using Pointer Arithmetic, we can judge the value of int, char etc…
- Constant Pointers can be declared by using the “const” keyword. Array name is known as constant pointer.
int iVar = 10;
int* const iPtr = &iVar; // iPtr is a pointer, which is const, that points to an int .
- In the above example you can change the value in iVar but not the address in iPtr.
*iPtr = 20; // allowed because the pointer (i.e. the address) is constant, while the
//value inside the pointer can be variable.
iPtr=100; // not allowed as iPtr (the pointer) is constant.