Pointer values in C language

Suppose, we have the following declaration:

int i=100, j=200, k=300;

This declaration tells the compiler to perform the following activities:

• Reserve space for three integer values in memory.
• Associate the variables i,j and k with these memory location.
• Store 100,200 and 300 at the locations i,j and k respectively as shown as below:

Variable	Address	Memory Locations
	0
	2
	4	100
I	……..	200
J	65534	300
K
variables	address	Values

The address of the variable cannot be accessed directly. The address of the variable can be obtained using address operator (& in C) .

Note : The address operator can be used with any variable that can be placed on the left side of an assignment operator.Since constants, expressions and array names can not be used on the left hand side of the assignment, and hence accessing address is invalid for constants, expressions and array names. The following are invalid:

Usage	Valid/Invalid	Reasons for invalidity
&100	Invalid	Address of a constant cannot be obtained.
&(p+100)	Invalid	Address of an expression cannot be obtained.
&(p+q)	Invalid	Address of an expression cannot be obtained.
Int a[10]; &a;	Invalid	Address of entire array cannot be obtained.
Register a; &a;	Invalid	Address of a register variable cannot be obtained.

Note : if a is an array , then address of the first location of the array is obtained either using : &a[0] or a.

Assume that the compiler has chosen the address 65530 for the variable i, the address 65532 for the variable j and 65534 for the variable k. These address assigned to variables i,j and k are called pointer values.

Definition : Memory is divided into number of storage cells called locations. All the locations in computer memory are numbered sequentially from 0 to 65535 ( with memory size of 64k) . Out of these address, the system assigns some addresses of the memory locations to the variables. These memory addresses assigned to variables by the system are called pointer values. 

Array in C language

Introduction

In this chapter, we will discuss a very important data type arrays. Let us see, “Why arrays?’’

We know that in one variable we can store the information of only one  data item. Suppose that a

Student has scored 90 marks. These marks can be stored in a variable as shown below:

int marks=90;

After executing this statement, the value 90 will be stored in the variable marks. Suppose there is

A need to store marks of 10 students. In such case, we are forced to use 10 variables like marksl,

Marks2… marks10. But, if it is required to store the marks of 100 students, definitely it is not

Feasible to use 100 variables marksl ,marks2…marks100, Now, the question is “How to store 100

different marks?” In mathematics, we use sets to group the items of similar kind, For example,

consider the set shown below :

marks = {80,90,45,99,100,36,88,96,67,92}

This is a set of marks of `10 students. Note that every item can be accessed by prefixing marks along

With the position of marks in the set. The first item 80 corresponds to the marks of first student,90

Corresponds to the marks of second student and so on i.e., marks1=80, marks2=90…marks 10=92.

In C language, this is where, the concept of arrays is used. Since all the marks are of the same type,

We can group and refer all the marks  with a common name using arrays.

Note: In general, if more number of data items of same type (kind) are to be accessed or read

or stored, then we use arrays.

The meaning of an array

Definition : An array is defined as an ordered set of similar data items. All the data items of

an array are stored in consecutive memory locations in main memory . The elements of an array

are of same data type and each item can be accessed using the same name. e.g. consider an

array of marks of 5 students as shown below:

80	90	45	99	100
Marks(0)	Marks(1)	Marks(2)	Marks(3)	Marks(4)

To refer an item in the array, we specify the name of the array along with position of the item. The

Position of the item must be written within square brackets ‘ []’.  The position of the item, The item enclosed within square brackets is called ‘subscript’ or ‘index’.

For example, the above figure represents an integer array called marks where marks of 5 students

Are stored. The marks of each student can be accessed as shown below:

       marks[0] i.e. 80 – represent marks of first student

       marks[ 1] i.e. 90- represent marks of second student

       marks[2] i.e. 45- represent marks of third student

      marks [3] i.e. 99- represent marks of fourth student

       marks[4] i.e. 100 – represent marks of fifth student

Thus using marks [0] through marks[4]  we can access the  marks of 5 students.

Note: Using marks [0] through marks [n-1] We can access the marks of n students in general.

In an array it not possible to have a group of items with different data types. Types. For example,

83	94.8	“Delhi”	‘3’	910
a[0]	a[1]	a[2]	a[3]	a[4]

Is invalid way of storing the elements in an array. This is because, it is a collection of int,  float, char

and string datatypes. Once we know the definition of an array. The next question is “How arrays

are classified?” The arrays can be classified based on how the data items are arranged for human

understanding. This is pictorially represented as shown below:

Pointer Declaration and Definition in c language

In C language, we know that all the variables should be declared before they are used. Pointer variable should also be declared before their use. The syntax to declare a pointer variable is shown below.

type *  identifier;

Type : type can be any datatype such as int, float , char etc. It may be derived or user defined data type also.
*       : The asterisk (*) in between type and identifier tells that the identifier is a pointer variable.
Identifier : Name given to the pointer variable. 

Example -1 : Consider the following declaration:
int * p;
The above declaration can be read as "p is pointer to integer variable" and this declaration informs the following points:

• The variable p is a pointer variable. So, it should contain the address of variable during execution.
• The type int refer to the type of the variable stored in pointer variable p i.e. the pointer variable p should contain address of an integer variable.

Example-2 : Consider the following declaration:
double *pd;
This declaration informs the compiler that pd is a pointer variable and can hold the address of a variable of type double.

Example-3 : In the declaration, the position of * is immaterial. For example, all the following declaration are same:
int *pa;
int * pa;
int*  pa;
Any of the above declaration informs that the variable pa is a pointer variable and it should contain address of integer variable.


Example-4 : Consider the multiple declaration as shown below:

int* pa,pb,pc;
Note : Here, we may wrongly assume that the variables pa, pb amd pc are pointer variables. This is because * is attached to int. This assumption is wrong. Only pa is a pointer variable, whereas the variables pb and pc are ordinary integer variables. For better readability, the above declaration can be written as shown below:

int *pa, pb, pc;
Now, we can easily say that pa is a pointer variable because of * operator, whereas pb and pc are integer variables and are not pointer variables. It is still better if the variable are declared in separated lines as shown below:
int *pa;
int pb;
int pc;

Initializing a pointer variable in C Language

Initializing a pointer variable

Initialization of a pointer variable is the process of assigning the address of a variable or memory to a pointer variable. The initialization of a pointer variable can be done using following three steps :
Step-1 : Declare a data variable.
Step-2 : Declare a pointer variable.
Step-3: Assign address of a data variable to pointer variable using & operator and assignment operator.
Note that the Step1 and 2 can be interchanged i.e. we can first declare a pointer variable, then declare a data variable and then initialize the pointer variable.

Example : Consider the following three statements:
int x; /* Step-1 : x is declared as a data variable */
int *px ; /* Step-2: px is declared as a pointer variable */
px= &x; /* Step-3 : copy address of data variable to pointer variable */
....
.....
Here , the variable x is declared as integer data variable. Since px is pointer variable of type integer, it should contain address of integer variable. So, using the statement : px = & x;
the valid address is stored in the pointer variable and hence the pointer variable px is initialized.

Example: Consider the following three statements:
int x ;  int *px; px=&x;
The above three statements can also be written as shown below:
int x;    int *px=&x;
Note : It is also possible to combine the declaration of data variable, pointer variable and initialization of pointer variable in one step as: int x, *px=&x;
Here, x is declared as a data variable, px is declared as pointer variable and px is initialized to address of data variable x.

Example : Consider the following statements:
int p, *ip;
float d,f;
ip=&p;  /* Valid Initialization */
..............
ip=&d;   /* Invalid initialization */
Note: First initialization is valid. In the second initialization , ip is a pointer to integer. So , it should contain address of integer variable. But , address of floating point variable d is stored in ip and hence it is invalid.

Example : Pointers are flexible i.e. a pointer can point to different data variables by storing the address of approximate variables. Consider the following declaration:
int x=10, y=20,z=30;
int *p;

p= &x;
.........
p=&y;
.........
p=&z;
..........

Note : It is observed from above example that the pointer variable p points to different memory location by storing the addresses of different variables. Thus, same pointer can be pointed to different data variables.

NULL Pointer in C language

Introduction

Definition : A NULL pointer is defined as the special pointer value that points to nowhere in the memory. If it is too early in the code to assign a value to the pointer, then it is better to assign NULL (i.e., \0 or 0) to the pointer.

For example , consider the following code:

#include<stdio.h>
int *p=NULL;
Here, the pointer variable p is a NULL pointer, this indicates that the pointer variable p does not point to any part of the memory. The value for NULL is defined in the header file "stdio.h". Instead of using NULL, we can also use '\0' or 0. The programmer can access the data using the pointer variable p if and only if it does not contain NULL. The error condition can be checked using the following statement:
if(p==NULL)
printf("p does not point to any memory\n");
else
{
printf("Access the value of p\n");
......................
}
Note : A pointer variable must be initialized. If it is too early to initialize a pointer variable, then it is better to initialize all pointer variables to NULL in the beginning of the code. This avoids unintentional use of an un-initialized pointer variable.

Example :  Consider the following statements:
int *x;
int y;
x=y;   /* Error*/
Note :  The value of data variable can not be assigned to a pointer variable. So, the statement x=y; result in an error . The correct statement is x=&y;

Pointer to Pointer in C language

Introduction

Definition : It is possible to make a pointer to point to another pointer variable. A variable which contains address of a pointer variable is called pointer to a pointer. For example, consider the following declarations:

int a;
int *p1;
int *p2;

• The first declaration instructs the compiler to allocate the memory for the variable a in which integer data can be stored.
• The second declaration tells the compiler to allocate a memory for the variable p1 in which address of an integer variable can be stored.
• The third declaration tells the compiler to allocate a memory for the variable p2 in which address of a pointer variable which points to an integer can be stored. The memory organization for the above three declaration is shown below:

Example: Memory organization after executing following assignment statement:

a=10;

p1=&a;

p2=&p1;

The memory organization after executing the statement a=10 is shown below:

The memory organization after executing the statement p1=&a is shown below:

The memory organization after executing the statement p2=&p1 is shown below:

The data item 10 can be accessed using three variables a, p1 and p2 as shown below:

a    refers to the data item 10

*p1 Also refers to the data item 10. Here, using p1 and only one indirection operator, the data item 10 can be accessed.

**p2  Also refers to the data item 10. Here, using p2 and two indirection operators the data item 10 can be accessed (i.e., *p2 refers to p1 and **p2 refers to a)

Floating point constant in C language

Floating point constant

Definition: The numeric values having fractional part are called floating point constants. All  negative Numbers should have prefix ‘- ’. A positive number may have a ‘+’ sign that is optional. Other
Character  are not allowed . The floating point constant can be represented using two forms as:

1. Fractional form
2. Exponent notation(Scientific notation)

Fractional from: Now, let us see  ‘‘how to represent floating point numbers using fractional form?  Explain giving examples.’’ A floating point number represented using fractional form has an integer part followed by a decimal point and a fractional part. We can omit the digits before the decimal point or after the decimal point. For example, 0.5, -0.99, -6, -9,+.9 etc all are valid floating point numbers.

Exponent notation (Scientific notation): Now , the question is ‘‘How to represent floating point numbers in scientific notation? Give examples.’’ The floating point number represented using Scientific notation (also called exponential notation) has three parts namely:
                          (part1)             (part2)                 (Part 3)
                         mantissa             e or E                  exponent

• The mantissa can be an integer or a floating point number represented using fractional Notation.The letter e or should follow mantissa.
• The exponent should follow e or E. The exponent has to be an integer ‘‘with optional ‘+’
• Sign’’ or ‘- ’ sign.

The following table shows invalid floating point numbers. The reasons for invalidity are also shown:

Floating point/ Real Constant	Valid / invalid	Reasons for invalidity
22.0/7	Invalid	/ is not allowed.
120	Invalid	There is no decimal point.
6.5e 8	Invalid	White space is not allowed between e and 8.
1.2.3	Invalid	More than one decimal point is not allowed.
2.123,4	Invalid	Comma is not allowed
10.5e-6.9	invalid	Fractional part 6.9 is not allowed in exponent part.