Near as I can tell in C++ declared entities such as functions and variables are ways of calling for stuff. For example:

char c;

This statement defines, declares, makes, creates, brings into being, whateveryouwanttocallit, a variable with the name c. This variable with the name c is of type character. That means that whenever in the program, especially on the right side of the equal (=) sign, you call the name 'c' the program will fetch a character.

Instead of "char c;" let's use the declare before for c:

char* c;

This declares a name c which when called will bring forth a "pointer to a character". As far as I can tell a pointer is an actual memory location. The type of a pointer tells the compiler how to interpret the information found at the memory location.

To avoid confusion in one's programming it might be a good idea to use a convention (i.e. habit) of using slightly different names for names which call forth stuff and names which calls forth pointers to stuff.

char c;
char* c_ptr;

Here using the name "c" will call forth a piece of char stuff. And, using the name "c_ptr" will call forth a memory location of the piece of char stuff.

Consider the following: char c;
c = 'a';
char* c_ptr;
c_ptr = &c;

First before we go too far let's define this operator "&". When & is put in front of a name it tells the compiler to get the address (memory location) of the stuff referred to by the name.

Okay that said let's look at what the above does.

"char c;"

tells the compiler to create enough memory space for a character. It also tells the compiler to name the character to be stored at this memory location 'c'.

c = 'a';

tells the compiler to stuff the character 'a' into the memory location so that now the name 'c' when uttered will bring forth the character 'a'.

char* c_ptr;

tells the compiler to set aside a piece of memory (I think a DWORD) and call it c_ptr. This piece is memory is to hold the type of information which will be a pointer to a character. This means that the memory location referenced by c_ptr will be a DWORD integer which will be itself an address to another part of memory which is to be a character.

c_ptr = &c;

tells the compiler to grab the memory address of the character named 'c' and stuff that number into the memory location named c_ptr.

Getting back to our intro to pointers let' recap from the above. If we utter the name 'c' the compiler/program will return a character -- 'a' in this case. If we utter the name 'c_ptr" the compiler/program will return a number which is the memory address where a character can be found.

But, given a pointer to a character how does one retrieve the character?

This is done through the '*' operator.

Consider the following:

Admittedly we could have done something more creative with the value returned by *c_ptr such as print it to screen or something. But you get the idea I hope.

Table 13-2 lists the operators used in conjunction with pointers.

The operator ampersand (&) returns the address of a thing which is a pointer. The operator asterisk (*) returns the object to which a pointer points. These operators can easily cause confusion. Table 13-3 shows the syntax for the various pointer operators.

Pointer Tutorial from book Practical C Programming (Nutshell Handbook) by Steve Oualline (Editor), Andy Oram (Editor)