/* This program demonstrates
 * 1. Reading and printing array values
 * 2. Address calculation for array elements
 * 3. Copying arrays - deep copy required
 * 4. Working with array elements as L-values and R-values
 * 5. Working with arrays and functions.
 *
 * * An array is a collection of variables that satisfies the following properties:
 * 1. All the variables in the array are of the same type.
 * 2. All the variables share the same name and are accessed by an index.
 * 3. The elements (individual variables) are ordered and start at index 0.
 * 4. The elements are in continuous memory locations.
 *
 * Array address Calculation
 * Since array elements are stored in contiguous memory locations, we can calculate
 * the address of any particular array element. We would need (a) the starting address
 * which is the address of array element 0. (b) the size of each element in bytes, and
 * (c) the index for the element we want the address for.
 *
 * Address = Starting_Address + size_of_one_element * index
 *
 * Arrays can be passed into function like regular variables.
 * However, arrays always pass by reference. So any changes made to the array
 * in the function will be preserved across the function call and will be refected
 * in main, or any other calling function.
 */

#include<iostream>
#include<cmath>
using namespace std;

/* Declare the functions here
 * when we pass an array into the function, we don't have to mention the size
 * the array. Mentioning it won't result in an error, but it is not necessary.
 * However, we have to specify it is an array, by using the []
 *
 * Function names are self-descriptive here. They are described while being defined.
 */
void cubeElements(double arr[], int numElements);

int main()
{
    double arr[10];     // declare the array

    //accept array values from the user
    cout<<"\nEnter values for the array: ";
    for(int i=0; i<10; i++)
    {
        cin>>arr[i];
    }

    cout<<"Printing array values: ";
    for(int i=0; i< 10; i++)
    {
        cout<< arr[i]<<"\t";
    }
    
    /* If we exceed the index, it will either print junk, or result in a segfault
     * That depends on the index, and whether that memory location is accessible.
     */
/*
    cout<<"Element at index -200: "<< array[-200]<<endl;
    cout<<"Element at index 400: "<< array[400]<<endl;
    cout<<"Element at index 73563769"<< array[73563769]<<endl; */

    double sum =0;

    /* We can perform all the operations we've seen so far using array
     * elements as variables
     * For example, to get the sum of all array elements
     * iterate through the array, add each value to the sum
     */
    for(int i=0; i<10; i++)
    {
        sum = sum + arr[i];
    }

    // Replace array elements with the rounded down square roots of new numbers.

    for(int i=0; i<10; i++)
    {
       arr[i] = static_cast<int> ( sqrt ( abs (arr[i] ) ) );
    }

    cout<<"Elements replaced by rounded down square roots: ";
    for(int i=0; i<10; i++)
    {
        cout<<arr[i]<<"\t";
    }
    cout<<endl;

    cout<<"The sum of the old elements in the array: "<<sum<<endl;

    /* Unlike individual variables, we cannot use the assignment operator =
   * to copy one array onto another. Instead, we would have to iterate
   * through the array and copy out each individual element. This is called
   * a deep copy of the array
   */

    const int NUM = 10;
    double copyArr[NUM];
    //deep copy
    for(int i=0; i<NUM; i++) {
        copyArr[i] = arr[i];
        cout << "Copy[" << i << "]: " << copyArr[i] << endl;
    }

    /* calling the cubeElements function. Note that when we call the
    * function, we only mention the name of the array.
    */

    cubeElements(copyArr, NUM);

    /* You will notice that changing the values of array elements in the
    * cubeElements function has resulted in squaring the values of the
    * array in the main function as well. This is because arrays always pass
    * by address (which resembles pass by reference), even without us
     * explicitly saying anything */
    cout<<"After function call: ";
    for(int i=0; i<NUM; i++)
        cout<<copyArr[i]<<"\t";
    cout<<endl;
    return 0;
}

/* Function cubeeElements - 2 parameters, returns nothing
 * iterates through the array and cubes the individual elements
 *
 * This function serves to demonstrate that arrays automatically pass by reference
 * We square each array element and put it back in the same place.
 */
void squareElements( double arr[], int size)
{
    for(int i=0; i<size; i++)
    {
        arr[i] = pow(arr[i],3);
    }
}