/* This program demonstrates:
 * 1. pointers.
 * 2. null pointers
 * 3. Reinterpret casts
 * 4. Pass by address
 * 5. Arrays and Pointers - pointer arithmetic
 *
 * Pointers are variables that can hold the address of another variable.
 *
 * Pointer Arithmetic
 * Since pointers are numbers (integers) we can do math with them.
 * However, the second operand in the operation is always multiplied by the size
 * of the type of the variable before the math is done.
 * We can make use of this property to work with arrays
 *
 * Pointers and arrays
 * When we declare an array, we are actually declaring a contiguous space of the
 * required amount of memory, and then uses the name os the array as a pointer to
 * the starting address of the array
 * Every time we use the [] operator with the array, we are actually doing pointer
 * arithmetic and then dereferencing the pointer
 * So, we can actually do the pointer math and dereference the pointer to move
 * through the array.
 * We can also actually change and update the pointer to move through the array.
 * However, if we do this, we have to make a note of the fact that the array name
 * is no longer pointing at the starting address of the array
 */

#include<iostream>

using namespace std;

void swap (int, int);
void swapRef( int &, int &);
void swapAddress(int *, int *);

int main()
{
    /* A variable has 5 properties: type, size, name, value and address
   * We can store the address of a variable in another variable.
   * This new variable that contains the address of another variable is called a pointer
   * We declare pointer using the * operator.
   * We get the address of a variable using the & operator.
   */

    int var = 50;       // regular integer variable

    int *ptr;           // declare a pointer
    ptr = &var;         // Initialize it with teh address of x

    cout<<"var: "<< var <<endl;           //prints the value of var
    cout<<"Address of var: "<< &var <<endl;  //prints teh address of var
    cout<<"ptr: "<< ptr <<endl;      // prints the value of ptr, which is the address of var
    cout<<"Address of ptr: "<< &ptr <<endl;      // prints the address of ptr

    /* Dereferencing the pointer is the process of accessing a variable through
    * the pointer. When we use * along with the pointer anywhere except for
    * declaration, we are dereferencing.
    * When we dereference, we are getting the value of the variable whose address
    * is stored in the pointer.
    */
    cout<<"Dereferencing ptr: "<< *ptr <<endl;       // prints the dereferenced ptr,
                                                    // which is the value of vqr

    int **q;        //Declare a two-level pointer
    q = & ptr;      //initialize q with the address of p

    cout<<"q: "<<q<<endl;       //prints q, which is the address of ptr
    cout<<"Address of q: "<<&q <<endl;          //prints the address of q
    cout<<"Dereference q: "<< *q <<endl;        //Prints q dereferenced, which is the value of ptr,
                                                // which is the address of var
    cout<<"Double dereference q: "<< **q <<endl;  //prints q double dereferenced,
                                                // which is dereferenced ptr, which is the value of var

    /* Null is the default 0 value for pointers, which signifies a pointer
     * pointing at nothing.
     * We can do it one of 3 ways.
     */
    ptr = NULL;     // c-style
    ptr = 0;
    ptr = nullptr;  // C++ style

    cout<<" Reached line 83"<<endl;

    //cout<< *ptr << endl; -> null pointer exception - will crash

    // We cannot assign pointers to integer literals
    //ptr = 0xffffcc3c;       // error

    /* Valid R-values for pointer assignment:
     * 1. Address of variables of the same type
     * 2. null
     * 3. pointer of the same type
     * 4. reinterpret cast
     */

    // We can assign a pointer to another pointer o the same type
    int *p2;
    int anothervar = 15;
    p2 = &anothervar;

    ptr = p2;
    cout<<"After re-assignment, *ptr: "<< *ptr<<endl;

    /* A reinterpret cast is a way to convert one type of pointer to another
     * The syntax is the same as static cast.
     * Here, we convert a pointer to a double to a pointer to an integer.
     */
    double y = 2.5;
    double *dblPtr = &y;
    // We cannot assign pointers across different types. We need to cast
    ptr = reinterpret_cast<int*>(dblPtr);

    cout<<"After reinterpret cast: ptr: "<<ptr<<endl;
    cout<<"*ptr: "<<*ptr<<endl;

    int a,b;
    cout<<"Enter 2 number: ";
    cin>>a>>b;

    //Swapping 3 ways - swap by vallue, swap by reference and swap by address
    cout<<"Pass by value:\n";
    cout<<"In main, before swap:\nA = "<<a<<", B= "<<b<<endl;
    swap(a,b);
    cout<<"In main, after swap:\nA = "<<a<<", B= "<<b<<endl;

    cout<<"Pass by Reference:\n";
    cout<<"In main, before swap:\nA = "<<a<<", B= "<<b<<endl;
    swapRef(a,b);
    cout<<"In main, after swap:\nA = "<<a<<", B= "<<b<<endl;

    cout<<"Pass by Address:\n";
    cout<<"In main, before swap:\nA = "<<a<<", B= "<<b<<endl;
    swapAddress(&a, &b);
    cout<<"In main, after swap:\nA = "<<a<<", B= "<<b<<endl;

    //Arrays can be easily manipulated by pointers.
    int array[10] = {12, 8, 9, 10, 15, 23, 45, -100, 6, 41};

    /* The following line will store the starting address (address of
     * location 0) in the pointer arrPtr
     */
    int *arrPtr = array;   // array names work like pointers

    // Both of the following lines will print the starting address of the array
    cout<<"arrPtr: "<<arrPtr<<endl;
    cout<< "array: "<<array << endl;

    /* The following loop runs 10 times, each time printing the contents of the array using
    * the pointer and the []notation that we're already familiar with.
    */
    cout<<"Print the array, using the [] operator: \n";
    for(int i=0; i<10; i++)
        cout<< arrPtr[i] <<"\t";

    /* Pointer Arithmetic:
     * ptr op x -> ptr op (type_size * x)
     *
     * The following loop runs 10 times, each time it dereference the pointer
     * after adding i to the pointer
     * Since it uses pointer arithmetic, the actual value added to the pointer
     * is i * sizeof(int) = i*4 here
     */

    cout<<"\nPrinting array, with pointer arithmetic:\n";
    for(int i=0; i<10; i++)
        cout<< *(arrPtr +i) <<"\t";

    /* The following loop does the same thing as the previous loop, but it makes use of operator precedence
     * to combine the addition and dereferencing into one step.
     * It also has the effect of changing the pointer.
     * At the end of the previous loop, the pointer will still be pointing at element number 0 of the array.
     * At the end of the following loop, the pointer will be pointing at the spaces beyond the last element
     * (element 9) of the array.
     */
    cout<<"\nPrinting array by changing the pointer:\n";
    for(int i=0; i<10; i++)
    {
        cout<<arrPtr<<"\t";
        cout<<*arrPtr ++<<endl; // arrPtr = arrPatr + 1 -> arrPtr = arrPtr + (4*1)

    }
    cout<<"After the loop: arrPtr: "<<arrPtr<<endl;

    /* Since we moved the pointer, we can use pointer arithmetic to move it
     * back to the array's starting address.
     */

    arrPtr = arrPtr - 10;
    cout<<"Starting address: "<< arrPtr<<endl;

    cout<<"Size of int: "<<sizeof(int)<<endl;       // size of an integer on your machine
    cout<<"Size of arrPtr: "<<sizeof(arrPtr)<<endl; // size of a pointer variable - not the
                                                    // same as the type of the pointer

    return 0;
}

// Swap using pass by value - implemented originally in functions2.cpp
void swap(int x, int y)
{
    cout<<"In function, before swap:\n x = "<<x <<", y = "<<y<<endl;
    int temp;
    temp = x;
    x = y;
    y = temp;
    cout<<"In function, after swap:\n x = "<<x <<", y = "<<y<<endl;
}

// Swap using pass by Reference - implemented originally in functions2.cpp
void swapRef(int &r, int &s)
{
    cout<<"In function, before swap:\n r = "<<r <<", s = "<<s<<endl;
    int temp;
    temp = r;
    r = s;
    s = temp;
    cout<<"In function, after swap:\n r = "<<r <<", s = "<<s<<endl;
}

/* Swap using pass by address
* Pass be address is the third way of passing parameters to a function.
* The variables are received into the function as pointers. This means
* the actual parameters in the function call were addresses.
* Whenever we need the values / need to change the values of the
* variables, we need to dereference the variables.
* New variables are not created at the function, but new pointers to the
* variables are created.
* Since we're dereferencing the pointers, any changes made to variables in
* the function will be maintained after we return from the function.
*/
void swapAddress(int *p, int *q)
{
    cout<<"In function, before swap:\n *p = "<< *p << ", *q = "<<*q<<endl;

    int temp;
    temp = *p;
    *p = *q;
    *q = temp;

    cout<<"In function, after swap:\n *p = "<< *p << ", *q = "<<*q<<endl;
}