Dynamic Arrays: Trying to properly expand the dynamic array and am trying to return a not NULL value from function

Question

1. I am trying to read the return value of the pointer_new_values variable.
2. The Dynamic Array's elements double once the array reaches it's max capacity using the growArray function.

#include <iostream>

//Using the returnValue variable in order to be able to see the return value of pointer_new_values. 
int returnValue;
int* growArray(int* pointer_values, int current_size);

int* growArray(int* pointer_values, int current_size)
{
//This dynamic array grows in size here.
    int* pointer_new_values = new int[current_size * 2];
    for (int i = 0; i < current_size; ++i)
    {
//This allows me to free memory from pointer values. Using delete. 
        pointer_new_values[i] = pointer_values[i];

    }
//Freeing the allocated memory from pointer_values.
    delete[] pointer_values;
//Returning the pointer_new_values variable, value which is equal to zero.
  *p_new_values = returnValue;
    return p_new_values;
//Here I return the value 0. 
   
// I am trying to read the pointer_new_values integer. From the int function.
}
int main()
{

    int next_element = 0;
    int size = 10;
    int* pointer_values = new int[size];
    int values;
    std::cout << "Please input a number:";
    std::cin >> values;
    while (values > 0)
    {

        if (size == next_element + 1)
        {
            //Now we implement the growArray
            pointer_values = growArray(pointer_values, size);
        }
        pointer_values[next_element] = val;
        std::cout << "Please input another number or exit." << std::endl;
        std::cin >> val;
        //Here I would like to read from the int GrowArray Function.
        std::cout << returnValue; 
//Returns the value of 0. 
        
    }
}

Answer 1

There are couple of issues with your code,

1. Even though array is expanded size is not updated
2. All the elements are added to the index zero of the array
3. In function growArray expanded array size has to be returned, no statements are executed after encountering of return
4. delete[] has to be used inorder to release memory allocated using new[]. refer

I tried to correct some part of your code,

#include <iostream>

int* growArray(int* pointer_values, int *size);

int* growArray(int* pointer_values, int* size)
{
    int current_size = *size * 2;
//This dynamic array grows in size here.
    int* pointer_new_values = new int[current_size];
    for (int i = 0; i < *size; ++i)
    {
        pointer_new_values[i] = pointer_values[i];

    }
    delete[] pointer_values;
    
    *size = current_size;
    
    std::cout<< "grow "<<*size<<std::endl;
    
    return pointer_new_values;
}

int main()
{
    int next_element = 0;
    int size = 1;
    int* pointer_values = new int[size];
    int values;
    std::cout << "Please input a number:";
    std::cin >> values;
    while (values >= 0)
    {
        if (size == next_element + 1)
        {
            //Size is updated on expanding the array
            pointer_values = growArray(pointer_values, &size);

        }

        pointer_values[next_element++] = values;
        //              ^^Here ,elements are added to new index 

        std::cout << "Please input another number or negative value for exit." << endl;
        std::cin >> values;
    }
    
     for (int i = 0; i < next_element; ++i)
    {
       std::cout<< pointer_values[i] << " ";

    }
}

Answer 2

I did some addition research and I made the dynamic array on much simpler and cleaner terms rather then using a function in order to double the array's size. It is probably unnecessary to return a value from a function anyway.

#include <iostream>
//Here is a simpler way of doing everything I described.
int size;
int main()
{
    int pointerAddition = 10;
    int* ten = &pointerAddition;
    do 
    {
        std::cout << "How many indexs do you want?" << std::endl;
        std::cout << "Please enter 0 to exit the loop." << std::endl;
//This allows me to allocate spaces during runtime. 
        std::cin >> size;
        int* dynamic_array = new int[size];
        std::cout << "Enter " << size << " numbers." << std::endl;
        for (int x = 0; x < size; x++) {
//Allows you to add an integer to each index of the array.
            std::cin >> dynamic_array[x];
        }
        std::cout << "You entered: " << std::endl;
        for (int x = 0; x < size; x++) {
//Prints each index of the array.
            std::cout << dynamic_array[x] << std::endl;
        }
        //Rather then using a function I settled for a simple if statment to keep it simple.
//If the size of the array is greater then or equal to 4 then double the array's size.
        if (size >= 4)
        {
            int size_doubled;
            size_doubled = size * 2;
            //Shows the size of the array doubled.
            std::cout << "The size of the array doubled." << std::endl;
            std::cout << size_doubled << std::endl;
            std::cout << "Ten has been added to the first index of the array." << std::endl;
            for (int y = 0; y < size_doubled; y++)
            {
                //Adds ten to the first index of the array.
                dynamic_array[0] += *ten;
                //Prints out the newly modified array.
                //In order to prove that the indexes have been added during runtime.
                std::cout << dynamic_array[y] << std::endl;
            }
        }
    //Deallocating memory every time the base operation is complete.
        delete[] dynamic_array;
    } while (size != 0);
    system("pause");
    return 0;
}