Question

I am learning about pointers and the new operator in class.

In my readArray function I am to read in a size. Use the size to dynamically create an integer array. Then assign the array to a pointer, fill it, and return the size and array.

I believe I’ve gotten that part corrected and fixed but when I try to sort the array, i get the error “uninitialized local variable temp used.”

The problem is though I get that error when I am trying to intialize it.
Any help appreciated thank you. Seeing my errors is very helpful for me.

#include <iostream>
using namespace std;

int* readArray(int&);
void sortArray(int *, const int * );

int main ()
{
    int size = 0;
    int *arrPTR = readArray(size);
    const int *sizePTR = &size;
    sortArray(arrPTR, sizePTR);

    cout<<arrPTR[1]<<arrPTR[2]<<arrPTR[3]<<arrPTR[4];

        system("pause");
        return 0;
}


int* readArray(int &size)
{
    cout<<"Enter a number for size of array.\n";
    cin>>size;
    int *arrPTR = new int[size];

    for(int count = 0; count < (size-1); count++)
    {   
         cout<<"Enter positive numbers to completely fill the array.\n";
         cin>>*(arrPTR+count);
    }

    return arrPTR;
}

void sortArray(int *arrPTR, const int *sizePTR)
{
    int *temp;
    bool *swap;

    do
    {
        swap = false;
        for(int count = 0; count < (*sizePTR - 1); count++)
        {
            if(arrPTR[count] > arrPTR[count+1])
            {
                *temp = arrPTR[count];
                arrPTR[count] = arrPTR[count+1];
                arrPTR[count+1] = *temp;
                *swap = true;
            }
        }
    }while (swap);
 }

Answer 1

You declared temp as a pointer. You need to allocate it on the heap before dereferencing and assigning to it later. However perhaps a variable on the stack would be preferable?

FYI: You should be aware of the memory leak in readArray as well which is leaving callers responsible for calling delete []

Edit: I hope this will help clear up some of the other problems.

#include <iostream>

int* readArray(int&);
void sortArray(int*, int);

int main ()
{
    int size(0); // use stack when possible
    int *arrPTR = readArray(size);
    sortArray(arrPTR, size);

    // arrays are zero based index so loop from 0 to size
    for (int index(0); index < size; ++index)
        std::cout << arrPTR[index];

    delete [] arrPTR; // remember to delete array or we have a memory leak!
    // note: because we did new[] for an array we match it with delete[]
    //       if we just did new we would match it with delete

    system("pause");
    return 0;
}

int* readArray(int& size)
{
    std::cout << "Enter a number for size of array.\n";
    std::cin >> size;
    int *arrPTR = new int[size]; // all news must be deleted!

    // prefer pre-increment to post-increment where you can
    for(int count(0); count < size; ++count)
    {   
         std::cout << "Enter positive numbers to completely fill the array.\n";
         std::cin >> arrPTR[count];
    }

    return arrPTR;
}

// passing size by value is fine (it may be smaller than pointer on some architectures)
void sortArray(int *arrPTR, int size)
{
    // you may want to check if size >= 2 for sanity

    // we do the two loops to avoid going out of bounds of array on last iteration
    for(int i(0); i < size-1; ++i) // the first to compare (all except last)
    {
        for(int j(i+1); j < size; ++j) // the second to compare (all except first)
        {
            // do comparison
            if (arrPTR[i] > arrPTR[j]) // from smallest to biggest (use < to go from biggest to smallest)
            {
                // swap if needed
                int temp(arrPTR[i]); // put this on stack
                arrPTR[i] = arrPTR[j];
                arrPTR[j] = temp;
            }
        }
    }
 }