/* This program demonstrates:
 * 1. Arrays and Pointers - pointer arithmetic
 * 2. Dynamic Memory Allocation
 * 3. Dynamic Arrays
 * 
 * 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
 *
 * Dynamic Memory allocation is when we
 * a. Allocate Memory outside the function call stack in heap memory
 * b. We do this during runtime (after the program has started running)
 *
 * The allocated memory must be explicitly destroyed by the programmer
 *
 * To allocate: Use the "new" operator/ keyword
 *
 * To deallocate: Use the "delete" operator/keyword
 *
 *  Dynamic Arrays:
 * So far, we have been declaring arrays in stack space. These arrays need to have
 * their size decided BEFORE COMPILING. That is why we had to use integer literals
 * or constant integers for size while declaring the arrays. We decided this size
 * hoping that it would be "large enough" to hold all the data the user is going
 * to put in.
 *
 * Also, we cannot create arrays in one function (that is not main) and use it in
 * other functions.
 *
 * Dynamic memory solves both of these problems.
 * 1. Declaration
 * We declare dynamic memory using the keyword "new".
 * When we declare a variable/array dynamically, the variable/array is created in
 * a completely different area of memory called the heap. This happens at RUNTIME.
 * So, we can use a variable to specify the size of the array.
 * 2. Access
 * We can access variables/arrays created in heap memory ONLY through a pointer.
 * 3. Deleting
 * Since we create this memory in runtime, this is not automatically deleted when
 * we return from a function. This is useful because we can create arrays in a
 * function and return it. However, we should take care to delete the memory we
 * created before we exit the program. To delete memory we created, we use the
 * keyword "delete". Please note that deleting doesn't have to be done in the
 * same function that created the array.
 *
 */ 
 
/* When we want to return an array from a function, the return type has to be
 * a pointer of the type of the array that we're returning.
 */
int* readArray(int count);
int* readDynArray(int count);

int main()
{
	int *ptr;           // declare a pointer
	//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
	
	/* Dynamic memory
   * We declare a variable in dynamic (heap) space and then can ONLY access it
   * through a pointer
   * A variable in dynamic space is declared using the keyword "new"
   * Once we're done using the variable, it is cleared from memory using the "delete" keyword
   */
	ptr = NULL;		// nullify the existing pointer

    ptr = new int;

    cout<<"Enter a number: ";
    cin>> * ptr;

    cout<<"Value of dynamic integer variable created: "<< * ptr <<endl;
    cout<<"Address of the pointer : "<< &ptr <<endl;
    cout<<"Address of dynamic integer variable created (and stored in ptr): "<< ptr <<endl;

    /* Once we're done with the variable, we need to deallocate the memory. 
     * That's the process of telling the OS "this memory is no longer in use"
     * To do that, use the delete operator.
     */

    delete ptr;
	
	 /* If we create a stack-space array in a function, it would be destroyed
    * when we return from the function. So, if we try to access that array from
    * main, it would either print junk values or crash with a segmentation fault
    */
    int *intArr = nullptr;

    int size;
    cout<<"Enter the number of elements: ";
    cin>>size;

    intArr = readArray(size);
    // The previous line will retrun an invalid reference, which would crash if we used it

    /* Instead of using the readArray function that creates an in-stack array
    * and returns an array that is subsequently destroyed, we can create a dynamic
    * array in the function, retrun it, use it in main, and delete it when it
    * is no longer required.
    */

    intArr = readDynArray(size);

    cout<<"\nPrinting from main: \n";
    for(int i=0; i<size; i++)
        cout<<intArr[i] <<"\t";
    cout<<endl;

	return 0;
}


/* This function creates an in-stack array of the given size
 * and reads some values in, and then returns the array.
 * This will compile, and run, but crash or print wrong values
 * if we try and access the returned array in main.
 * This is because the array is destroyed when we return from
 * the function, and the returned address is pointing
 * to memory that technically is unallocated.
 */
int* readArray(int count)
{
    int array[100];
    cout<<"Enter the values: ";
    for(int i=0; i<count; i++)
        cin>>array[i];

    cout<<"Printing from the function:\n";
    for(int i=0; i<count; i++)
        cout<<array[i]<<"\t";
    cout<<endl;

    cout<<"Value at element -5: "<<array[-5]<<endl; // out of bounds, but will print junk

    return array;
}

/* We dynamically create an array of the given size
 * We create a pointer (which can point to arrays) and the use the "new" operator
 * to create the array.
 * We can then use the pointer like a regular array variable.
 * Finally, we can just return that pointer.
 * This array will be active and accessible in mian until it is deleted.
 */
int* readDynArray(int count)
{
    int *array = new int[count];
    cout<<"Enter the values: ";
    for(int i=0; i<count; i++)
        cin>>array[i];

    cout<<"Printing from the function:\n";
    for(int i=0; i<count; i++)
        cout<<array[i]<<"\t";
    cout<<endl;

    //cout<<"Value at element -5: "<< array[-5] << endl; // out of bounds in a dynamic array - segfault

    return array;
}