從函數返回到主函數的指針數組為NULL

Question

我被要求在C中創建一個函數，該函數獲取一個int數組，它的大小和一個表示排序是需要升序還是降序的字符（升序為0，降序為任何其他char），並返回一個指針數組。 如果排序是遞增的，則指針將從int數組中的值的最小值到最大值進行排序。 這樣，一切工作良好，直到將指針數組返回值為NULL的值。 我的意思是，在函數結束並返回數組之前，數組中有一些值（它們也被很好地排序了），但是當主函數從函數獲取地址時，它為空。 有人熟悉這個問題嗎？

謝謝！

#include <stdio.h>

#define SIZE 100

// Functions declaration
int** pointerSort(int* arr, unsigned int size, char ascend_flag);
void sortMerge (int** sortedArr, int left, int right, char ascend_flag);
void mergeSortAscend (int** arr, int left, int middle, int right);
void mergeSortDescend (int** arr, int left, int middle, int right);
void copyAddress(int** addressArray, int* arr, unsigned int size);

int main()
{
    int** sortedArr;
    int  arr[5] = {8,1,7,2,4};
    int size = 5;

    sortedArr = pointerSort(arr, size, '1');

    return 0;
}

// The pointerSort function gets an array, its size and a flag representing "sort by" (ascending, descending)
int** pointerSort(int* arr, unsigned int size, char ascend_flag)
{
    // Variables declaration
    int* sortedArr[size];

    // Copying the addresses of each value in arr to an addresses array
    copyAddress(sortedArr, arr, size);

    // Sending the array of addresses, its start and end and the ascend_flag to the sortMerge function
    sortMerge(sortedArr, 0, size - 1, ascend_flag);

    return (sortedArr);
}

void sortMerge (int** sortedArr, int left, int right, char ascend_flag)
{
    // Variables declaration
    int middle = (left + right) / 2;

    // Checking if there are more than one cell
    if (left < right)
    {
        // Splitting the array into two
        sortMerge(sortedArr, left, middle, ascend_flag);
        sortMerge(sortedArr, middle + 1, right, ascend_flag);

        // Checking if the sort requested is ascending or descending
        if (ascend_flag != '0')
        {
            mergeSortAscend(sortedArr, left, middle, right);
        }
        else
        {
            mergeSortDescend(sortedArr, left, middle, right);
        }
    }
}

void mergeSortAscend (int** arr, int left, int middle, int right)
{
    int l = left, m = middle + 1, r = right, i = left;
    int* temp[SIZE];

    while ((l <= middle) && (m <= right))
    {
        if (*(arr[l]) > *(arr[m]))
        {
            temp[i] = arr[m];
            m++;
        }
        else
        {
            temp[i] = arr[l];
            l++;
        }
        i++;
    }

    if (l <= middle)
    {
        while (l <= middle)
        {
            temp[i] = arr[l];
            l++;
            i++;
        }
    }

    if (m <= right)
    {
        while (m <= right)
        {
            temp[i] = arr[m];
            m++;
            i++;
        }
    }
    for (int k = left; k <= right; k++)
    {
        arr[k] = temp[k];
    }
}

void copyAddress(int** addressArray, int* arr, unsigned int size)
{
    int i;

    for (i = 0; i < size; i++)
    {
        addressArray[i] = &(arr[i]);
    }
}

void mergeSortDescend (int** arr, int left, int middle, int right)
{
    int l = left, m = middle + 1, r = right, i = left;
    int* temp[SIZE];

    while ((l <= middle) && (m <= right))
    {
        if (*(arr[l]) <= *(arr[m]))
        {
            temp[i] = arr[m];
            m++;
        }
        else
        {
            temp[i] = arr[l];
            l++;
        }
        i++;
    }

    if (l <= middle)
    {
        while (l <= middle)
        {
            temp[i] = arr[l];
            l++;
            i++;
        }
    }
    if (m <= right)
    {
        while (m <= right)
        {
            temp[i] = arr[m];
            m++;
            i++;
        }
    }
    for (int k = left; k <= right; k++)
    {
        arr[k] = temp[k];
    }
}

Answer 1

int* sortedArr[size]; int** pointerSort(int* arr, unsigned int size, char ascend_flag)在函數返回后立即失效，因為它是堆棧中分配的自動變量。

您需要一個永久存儲。 例如，通過malloc函數為堆上的sortedArr分配內存並返回它。

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

#define SIZE 100

// Functions declaration
int** pointerSort(int* arr, unsigned int size, char ascend_flag);
void sortMerge (int** sortedArr, int left, int right, char ascend_flag);
void mergeSortAscend (int** arr, int left, int middle, int right);
void mergeSortDescend (int** arr, int left, int middle, int right);
void copyAddress(int** addressArray, int* arr, unsigned int size);

int main(void)
{
    int** sortedArr;
    int  arr[5] = {8,1,7,2,4};
    int size = 5;
    int i =0;

    sortedArr = pointerSort(arr, size, '1');

    if(sortedArr) // memory was allocated
       for(i=0; i<5; i++){
           printf("%d ", *sortedArr[i]);
       }

    free(sortedArr);
    return 0;
}

// The pointerSort function gets an array, its size and a flag representing "sort by" (ascending, descending)
int** pointerSort(int* arr, unsigned int size, char ascend_flag)
{
    // Variables declaration
    //int* sortedArr[size];
    int ** sortedArr = malloc( sizeof(int *) * size);
    if(sortedArr == NULL) return NULL; // no memory

    // Copying the addresses of each value in arr to an addresses array
    copyAddress(sortedArr, arr, size);

    // Sending the array of addresses, its start and end and the ascend_flag to the sortMerge function
    sortMerge(sortedArr, 0, size - 1, ascend_flag);

    return (sortedArr);
}

void sortMerge (int** sortedArr, int left, int right, char ascend_flag)
{
    // Variables declaration
    int middle = (left + right) / 2;

    // Checking if there are more than one cell
    if (left < right)
    {
        // Splitting the array into two
        sortMerge(sortedArr, left, middle, ascend_flag);
        sortMerge(sortedArr, middle + 1, right, ascend_flag);

        // Checking if the sort requested is ascending or descending
        if (ascend_flag != '0')
        {
            mergeSortAscend(sortedArr, left, middle, right);
        }
        else
        {
            mergeSortDescend(sortedArr, left, middle, right);
        }
    }
}

void mergeSortAscend (int** arr, int left, int middle, int right)
{
    int l = left, m = middle + 1, r = right, i = left;
    int* temp[SIZE];

    while ((l <= middle) && (m <= right))
    {
        if (*(arr[l]) > *(arr[m]))
        {
            temp[i] = arr[m];
            m++;
        }
        else
        {
            temp[i] = arr[l];
            l++;
        }
        i++;
    }

    if (l <= middle)
    {
        while (l <= middle)
        {
            temp[i] = arr[l];
            l++;
            i++;
        }
    }

    if (m <= right)
    {
        while (m <= right)
        {
            temp[i] = arr[m];
            m++;
            i++;
        }
    }
    for (int k = left; k <= right; k++)
    {
        arr[k] = temp[k];
    }
}

void copyAddress(int** addressArray, int* arr, unsigned int size)
{
    int i;

    for (i = 0; i < size; i++)
    {
        addressArray[i] = &(arr[i]);
    }
}

void mergeSortDescend (int** arr, int left, int middle, int right)
{
    int l = left, m = middle + 1, r = right, i = left;
    int* temp[SIZE];

    while ((l <= middle) && (m <= right))
    {
        if (*(arr[l]) <= *(arr[m]))
        {
            temp[i] = arr[m];
            m++;
        }
        else
        {
            temp[i] = arr[l];
            l++;
        }
        i++;
    }

    if (l <= middle)
    {
        while (l <= middle)
        {
            temp[i] = arr[l];
            l++;
            i++;
        }
    }

    if (m <= right)
    {
        while (m <= right)
        {
            temp[i] = arr[m];
            m++;
            i++;
        }
    }

    for (int k = left; k <= right; k++)
    {
        arr[k] = temp[k];
    }
}

測試：

1 2 4 7 8