使用指针作为动态分配的数组

Question

I'm trying to write a program that dynamically allocates memory for an array, which the user then fills with integer values and the program sorts said integer values. However, it seems that my array isn't working as intended. I have managed to get the program working with a static array, but the dynamic allocation is causing me a lot of problems with incorrect values and whatnot. Here's what I have so far for the dynamically allocated version (if it would help you guys, I can also provide the version that uses a static array):

#include <stdio.h>
#include "genlib.h"
#include "simpio.h"

void sortArray (int *numbers, int i2); 
int indexMax (int *numbers, int low, int high);
void swap (int *num1, int *num2);
int getArray (int *numbers);
void displayArray (int *numbers, int i2);

main()
{
    int *numbers, i2;
    i2=getArray(numbers); 
    sortArray(numbers, i2); 
    displayArray (numbers, i2); 
}

int getArray (int *numbers)
{
    int i, i2;
    printf("Please enter the amount of elements you wish to sort: ");
    i2=GetInteger();
    numbers=(int *)malloc(i2*sizeof(int));
    for(i=0;i<i2;i++, numbers++)
    {
        printf("Enter next integer: ");
        *numbers=GetInteger();
        printf("\n");
    }
    return(i2);
}

void displayArray (int *numbers, int i2)
{
    int i;
    printf ("\nThe sorted list is: \n\n");
    for (i=0;i<i2;i++, numbers++)printf ("%d\n", *numbers); 
}

void sortArray (int *numbers, int i2)
{
    int i, minInd;
    for(i=0;i<i2;i++)
    {
        minInd=indexMax(numbers, i, i2-1);
        swap(&numbers[i], &numbers[minInd]);        
    }
}

int indexMax (int *numbers, int low, int high)
{
    int i, maxInd;
    maxInd=high;
    for (i=high;i>=low;i--)
    {
        if(*(numbers+i)>*(numbers+maxInd)) maxInd=i;
    }
    return (maxInd);
}

void swap (int *num1, int *num2)
{
    int temp;
    temp=*num1;
    *num1=*num2;
    *num2=temp;
}    

Answer 1

Try this:

int main(void)
{
    int *numbers, i2;
    i2 = getArray(&numbers); 
    sortArray(numbers, i2); 
    displayArray (numbers, i2); 

    return 0;
}

int getArray (int **numbers)
{
    int i, i2;
    printf("Please enter the amount of elements you wish to sort: ");
    i2 = GetInteger();
    *numbers = malloc(i2 * sizeof int);

etc...

You simply need one more level of indirection to make int getArray(int**) return a pointer to an allocated array.

Answer 2

Here is a working solution:

#include <stdio.h>
#include <stdlib.h>

void sortArray (int *numbers, int i2); 
int indexMax (int *numbers, int low, int high);
void swap (int *num1, int *num2);
int getArray (int **numbers);
void displayArray (int *numbers, int i2);

main()
{
    int *numbers, i2;
    i2=getArray(&numbers); 
    sortArray(numbers, i2); 
    displayArray (numbers, i2); 
}

int getArray (int **numbers)
{
    int i, i2;
    printf("Please enter the amount of elements you wish to sort: ");
    scanf("%d", &i2);
    (*numbers) = malloc(i2 * sizeof(int));
    int *temp = *numbers;
    for(i = 0; i < i2; i++)
    {
        printf("Enter next integer: ");
        scanf("%d", &temp[i]);
        printf("\n");
    }
    return(i2);
}

void displayArray (int *numbers, int i2)
{
    int i;
    printf ("\nThe sorted list is: \n\n");
    for (i=0;i<i2;i++, numbers++)printf ("%d\n", *numbers); 
}

void sortArray (int *numbers, int i2)
{
    int i, minInd;
    for(i=0;i<i2;i++)
    {
        minInd=indexMax(numbers, i, i2-1);
        swap(&numbers[i], &numbers[minInd]);        
    }
}

int indexMax (int *numbers, int low, int high)
{
    int i, maxInd;
    maxInd=high;
    for (i=high;i>=low;i--)
    {
        if(*(numbers+i)>*(numbers+maxInd)) maxInd=i;
    }
    return (maxInd);
}

void swap (int *num1, int *num2)
{
    int temp;
    temp=*num1;
    *num1=*num2;
    *num2=temp;
}

The thing is in your main when you are declaring int *numbers , numbers pointer is pointing to some junk memory location as local variables can have any garbage value, so while you are passing this numbers pointer to getArray() function you are passing its value, Suppose numbers is pointing to some random value = 1234 and suppose address of numbers is = 9999. Now when you call getArray(numbers) you tell taht whatever is there in numbers pass it to getArray's numbers variable that we are letting is 1234.

Then when you allocate memory to numbers that is local variable of getArray() function not main's and it might have address suppose = 0x8888. Then malloc allocates some address space as specified and stores the start address of that allocated address space(suppose ie = 0x7777) into location 0x8888 not 0x9999 which is the adress of main's numbers variable.

Thus when the getArray function ends and next time you call sortArray you pass it value present in numbers variable of main which is still junk 1234. and the actual value you should be passing is present at address 0x8888.

Answer 3

As an aside, you can use the C library function qsort() to do the sorting work for you. Here is an example:

int main(void)
{
    int a[]={4,7,9,1,34,90,66,12};

    qsort(a, sizeof(a)/sizeof(a[0]), sizeof(int), compare);

    return 0;
}

int compare(const void *a, const void *b){
     const int *x = a, *y = b;
     if(*x > *y)
       return 1;
     else
       return(*x < *y) ? -1: 0;
}  

Works just as well with dynamically allocated int arrays, or char arrays