//Sample program for c++ pointer
signed main()
{
    int* p;
    //Right now, p contains no particular myval in this C++ code.
}

   The asterisk in the above specifies that we have a pointer variable.    Let's say we want to define an int variable and then we want to define a pointer variable, which will store the memory address of this int:

 //c++ pointer using an int variable 

signed main()
{
    int myval(7);
    int* p_myval;
    //Right now, p_myval contains no particular myval.
    p_myval = &myval;
    //Now, p_myval in this c++ program contains the memory address of the variable myval
}

    With &myval, & is referred to as "the address-of operator". The expression &myval is of the c++ type int*. We then store this int* myval in our int* variable, which is p_myval.    Now, we will actually use this pointer:    

//Sample program for c++ pointer 

signed main()
{
    int myval = 7;
    int* p_myval = &myval;
    *p_myval = 6;
}

    With *p_myval = 6, the asterisk is referred to as "the dereference operator". It turns the expression from an int* into an int. The statement has the effect of setting the myval of myval to 6.    So now what are the uses of pointers in c++? Let us see something about how and when they should be used:  

  A) When the pointer must be re-seated.

  B) When arrays are involved.

 Consider a string, an array of characters: 

signed int main()
{
    char my_name[] = "Code";
}

   Here's what the string (char c++ pointer) looks like in memory:

Name of Variable	Type of Variable	Address in Memory	Value Stored
my_name	Char	108	'C'
	char	109	'o'
	char	110	'd'
	char	111	'e'
	char	112	'\0'

int main()
{
    char my_name[] = "Code";
    char* k( &my_name[1] );
}

   Now, what k points to looks like so in memory:

Name of Variable	Type of Variable	Address in Memory	Value Stored
my_name	Char*	116	109
	char	109	'o'
	char	110	'd'
	char	111	'e'
	char	112	'\0'

signed int main()
{
    int myval(5);
    int myvalue2 = 7;
    int* p_primate;
    p_primate = &myval;
    *p_primate = 9;
    p_primate = &myvalue2;
    *p_primate = 10;
}

   Guess what kind of variable we have in the following: 

signed main()
{
    signed** p_p_cow;
}

    An int* c++ pointer points to an int, so an int** points to an int*. In English: The variable p_cow above stores a memory address. At that memory address exists a variable of type int*. This int* variable also stores a memory address, at which exists an int. Take the following: 

//Snippet for c++ pointer to pointers 

int main()
{
    int cow(7);
    int* p_cow = &cow;
    int** p_p_cow(&p_cow);
    int*** p_p_p_cow = &p_p_cow;
}

    Here's what the above c++ pointers look like in memory:

Name of Variable	Type of Variable	Address in Memory	Value Stored
Cow	Int	108	7
p_cow	int*	110	108
p_p_cow	int**	112	110
p_p_p_cow	int***	114	112

//Using c++ pointer to pointer 

int main()
{
    int cow(7);
    int* p_cow = &cow;
    int** p_p_cow(&p_cow);
    int*** p_p_p_cow = &p_p_cow;
    ***p_p_p_cow = 8;
}

    C++ Pointers are commonly used when working with strings. Let's define a function; this function will be supplied with a string. We're going to change the 2nd, 5th and 7th characters of the string: 

void ChangeString(char* const p_first_char)
{
    p_first_char[1] = 'a';
    p_first_char[4] = 'b';
    p_first_char[6] = 'c';
}

    Or we can define a function, which will be supplied with a string. The function will return the first instance of the character 't' in the string: 

char* GetFirstT(char* p_first_char)
{

for ( ; *p ; ++p)
{
if ( *p == 't' ) return p;
}
return 0;

} 

signed main()
{

char the_alphabet[] = "abcdefghijklmnopqrstuvwxyz";
char* p_t = GetFirstT(the_alphabet);

}

   Now I'm going to talk about c++ pointers and constness. If you want a const c++ pointer variable, a c++ pointer variable whose value you can't change after initialization, then stick the const directly beside the variable's name: 

signed main()
{

int myval = 5;
int myvalue2(8);
int* const p_k = &myval;
p_k = &myvalue2; //COMPILE ERROR
*p_k = 3; //No problem, the variable to which it points is non-const

}

   If you want a non-const c++ pointer variable, but you want the variable to which it points to be const, then: 

signed main()
{

int myval(7);
int myvalue2 = 6;
const int* p_k = &myval;
p_k = &myvalue2; //No problem, the variable is non-const
*p_k = 7; //COMPILE ERROR

}

   If you want a const c++ pointer that points to a const variable then: 

signed int main()
{

int myval(17);
int myvalue2 = 4;
const int* const p_k = &myval;
p_k = &myvalue2; //COMPILE ERROR
*p_k = 32; //COMPILE ERROR

}