Constant pointer cannot be reassigned to different objects
once its initialized. It can be used to modify the object
that it points to.

Eg. 
int *const constPtr;

   *constPtr =0; //can be modified like this

Pointer to constant can be reassigned to point to another
object of same type.

int const *ptrConst;
    
    ptrConst = 0;

char * const p;  ->it is const pointer to char
  const char * p;  ->it is pointer to const char

Pointer is a variable containing the addres of another 
variable;
Constant pointer is a variable which points to a variable 
constantly.it means that , once it is initialised,it cannot 
be changed.Till the end of program,it points to that 
variable only;
EXAMPLE:
char k,m;
const char *p=&k;
p=&m;//(syntax error)

********
A pointer to a constant is a pointer such that the contents 
of the variable(pointed by the pointer)cannot be modified
throuhg the pointer;
EXAMPLE:
char m='l';
char * const p;
p=&m;
*p='u';//syntax error
m='k';//no syntax error

Pointer to a consttant ::: such that the value to which
pointer points  can't be changed 
const int *ptr1=7
 *ptr=8  // invalid
constant pointer :::: pointer direction can't be cheged .
int *const x =6;
 x=7 or x=&i // invalid
Location of pointer can't be chenged.

CONSTANT POINTER: A pointer will always point to one
object.it is initialized at the time of declaration.
e.g
int i=20,j;
int* const p=&i;
cout<<*p; //will print 20
*p=30;//works....i.e the value pointed by the constant
pointer can be changed
//now if write
p=&j;//error

POINTER TO CONSTANT

it can be declared as 
const int *p;
or
int const *p;
int i=10,j=30;
p=&i;
cout<<*p;
*p=10//error...the value is constant pointed by p
//pointer p is not constant so it can now point to another
variable of integer type
//so if we write
p=&j  //it will now point to a variable j

that's all.........

//POINTER TO CONSTANT vs CONSTANT POINTER

#include<iostream.h>
#include<conio.h>

//POINTER TO CONSTANT

void f1()
{
	 int i=10,j=20;
	 const int* pi=&i;
	 cout<<*pi<<endl;
	 //*pi = 200;   ERROR : CANNOT MODIFY A CONST OBJECT IN f1()
	 pi=&j;    // IT CAN POINT ANOTHER CONSTANT
	 cout<<*pi<<endl;
}

//CONSTANT POINTER

void f2()
{
	 int i=100,j;
	 int* const pi=&i;
	 cout<<*pi<<endl;
	 *pi = 200;    // IT CAN ASSIGN ANOTHER VALUE AT THIS ADDRESS
	 cout<<*pi<<endl;
	 //pi=&j;  ERROR : CANNOT MODIFY A CONST OBJECT IN f2()
}


void main()
{
	clrscr();
	f1();
	f2();
	getch();
}