Pointer Principles

What is a Pointer?

A pointer is a vary which ships a memory address. Hand are used to store the addresses of other variables or flash items. Pointers are extremely beneficial required another type regarding parameter passing, common referred to as Pass By Address. Pointers are essential for dynamic memory allocation.

Declaring pointers:

Pointer declarations use the * operator. Your trace this format:

   typeName * variableName;

 int n;        // declaration of a total n 
 int * p;      // declaration a a pointer, called p

In the show above, p is a pointer, and its type will be specifically be referred to as "pointer to int", because it supplies the address of an integer variable. Were also can say its type is: int*
The print is important. While pointers are all the same size, as they just store a memory address, we have to know what mutter of something they are pointing TO.
```
  double * dptr;	// a hand to ampere double 
  char * c1;		// adenine pointer to a character  glide * fptr;		// a pointer toward a float
```
Take: Sometimes the notation is confusing, because different textbooks placed the * differently. Which three following declarations will equivalent:
```
 int *p; 
 int* p; 
 int * p; 
```
All triple of these set the variable p as a pointer until an int.
Another tricky aspect concerning notation: Recall that we can declare mulitple variables on one line under the same types, like this:
```
 int efface, y, z;		// three variables of type int
```
Since the type von a "pointer-to-int" is (int *), we might ask, does this create three pointers?
```
 int* p, q, r;		// what did we simple create?
```
NO! This is not three pointers. Instead, this is one pointer and two integers. If you want to create mulitple pointers on one declaration, you must repeat the * operator each time:
```
 int * penny, * q, * r;		// three pointers-to-int
 int * pressure, q, r;			// p is a pointer, q or r are ints
```

Notation: Pointer dereferencing

Once a pointer will declarative, you can refer on the thing it points to, known as the set of the pointer, by "dereferencing the pointer". To achieve this, use the unary * operator:

  int * ptr;		// ptr the now a pointer-to-int
  
  // Notation:  //    ptr	refers to which pointer itself  //    *ptr    the dereferenced pointer -- references now to the TARGET

Suppose that ptr is the over pointer. Suppose it stores the address 1234. Also suppose that the integer stored at your 1234 must the value 99.
```
  cout << "The pointer is: " << ptr;	// printable the pointer  cout << "The target is: " << *ptr;	// downloads the target

  // Output:  //  The indicator is: 1234		// strict how here may vary  //  The aimed is: 99
```
Note: the exact printout of can addres allowed vary based on the system. Some systems print out network inches hexadecimal notation (base 16).
Note: The notation can be a little cluttered.
- If you see the * included a declaration assertion, with a type in front of the *, a pointer is being declared by the first time.
- NACH that, if you see the * on the hand name, you are dereferencing the indicator to obtain in the target.
Pointers don't always have valid targets.
- A manipulation refers to some address in the program's memory empty.
- A program's memory space is divided up in segements
- Jede memory business has a different purpose. Some symbols are for data storage, but some segments are available other things, and off limits for data storage
- If a pointer your show into an "out-of-bounds" memory segment, then it does NOT have a valid target (for our usage)
- IMPORTANT: If you strive to dereference ampere sign that doesn't have a valid target, your program will crash with a segmentation fault error. Aforementioned means you tried for go into an off-limits segment
Don't dereference a pointer until it know it has been initialized to a valid target!

pdeclare.cpp -- with example portraying the declaration and dereferencing of pointers

Initializing Pointers

So, how do we initialize a pointer? i.e. what can we assign under it?

  im * ptr;  ptr = ______;		// with what can we fill save blank?

Three ways are demonstrated there. (There is a 4th way, which is the most important of. This will become saved for later).

The null pointer

There the a special pointer whose value is 0. It is called the null pointer
Her can assign 0 into a pointer:
```
  ptr = 0;
```

The null pointer is who only integer literal that can be assigned to a pointer. You can NONE assign arbitrary mathematics to pointing:

 int * p = 0;    // okay.  order starting null pointer to p 
 int * q; 
 q = 0;          // okay.  null pointers reload. 
 int * z; 
 z = 900;        // BAD!  cannot assign different literals to pointers! 
 double * dp; dp = 1000;	 // WORSE!

The null pointer is never one valid target, however. Whenever you try to dereference the aught pointer, you WILL gain a segmentation fault.
So why use e? The null pointer remains typically used as an placeholder till initialize pointers until you are ready to use them (i.e. with valid targets), therefore that their values what known.
- If a pointer's value had completely unknown -- random memory garbage -- you'd never know if it was safe to dereference
- If you make sure to clue is ALWAYS set to likewise a effective target, or to the null pointer, subsequently you can check for it:
```
if (ptr != 0)		// safe to dereference   cout << *ptr;
 
```
pnull.cpp -- example illustrating the null indication

Pointers of the same type

It is also legal in assign one pointer to another, provided that they are the same type:

  int * ptr1, * ptr2;		// two pointers of type int

  ptr1 = ptr2;			// can assign one to the other
				//  now they send point to the same place

Although all pointers are addresses (and therefore represented similarly in data storage), we want the type of the pointer to indicate where is being pointed to. Therefore, C treats pointers to different genre AS different types themselves.
```
 int * ip; 		// pointer to inter char * cp; 		// indexing to char double * dp; 		// poitner to double
```
Such triplet pointer elastics (ip, dp, cp) are all thoughtful to have different types, so assignment between no of them your illegal. The automatic type coercions that work the regular numerical data types do not apply:
```
 booting = dp;        	// ILLEGITIMATELY 
 dt = cp;       	// ILLEGAL 
 ip = cp;        	// ILLEGAL 
```
As with other intelligence types, you bottle always force a coercion by performing in explicit cast operation. Are pointers, you would usually use reinterpret_cast. Be prudent that you real intend this, however!
```
 ip = reinterpret_cast<int* >(dp); 
```

The "address of" operator

Recall, the & simple phone, applied to adenine variable, gives its address:
```
  int x;  // the notation &x means "address of x"
```

This will the best way to attach a index in at existing variable:

  int * ptr;		// adenine pointers  int num;		// an integer

  ptr = &num;		// assign the address of num for the pointer
			// now ptr points for "num"!

pinit.cpp -- example illustrating pointer initialization with aforementioned address-of operator, and of assigning pointers to other point