使用 malloc 创建数组并将其作为函数传递

Question

我正在尝试学习如何使用 C（来自 C#），而 malloc 一直是数组中给我带来麻烦的事情之一。我有一个非常简单的函数来获取按非降序 { -1, 0, 1, 2, 3} ) 排序的数组及其大小，对每个值进行平方，并根据平方值按升序对其进行排序。

/// <param name="nums">integer array nums</param>
/// <param name="size">Size of array</param>
/// <returns>Sorted and squared array</returns>
int *sortedSquaredArray(int* nums, int size)
{
    //Starting from both ends of the array, square and do a semi-merge sort
    int *sortedArray = (int *)malloc(size * sizeof(int));

    int startIdx = 0;
    int endIdx = size - 1;
    int cnt = size - 1;
    int a;
    int b;
    int c;

    while (startIdx < endIdx)
    {
        a = nums[startIdx] * nums[startIdx];
        b = nums[endIdx] * nums[endIdx];

        if (a >= b)
        {
            sortedArray[cnt] = a;
            startIdx += 1;
        }
        else
        {
            sortedArray[cnt] = b;
            endIdx += 1;
        }
        cnt -= 1;
    }

    //final loop
    c = nums[startIdx] * nums[startIdx];
    sortedArray[0] = c;


    return sortedArray;

当我传回数组并尝试打印它时（我在 Visual Studio 的控制台中）只有最终值在 sortedArray 中正确设置，这让我觉得我正在写信给完全错误的内存地址，但我不确定为什么。我也不太清楚，如果您将指针传回另一个函数，何时从 malloc 释放已用内存。

/// Run the sortedSquaredArray test
/// </summary>
void runSortedSquaredArrayTest()
{
    int nums1[] = { -4, -1, 0, 3, 10 };

    int *res = sortedSquaredArray(nums1, 5);
    printf("val1 %d, val2 %d, val3 %d, val4 %d, val5 %d", res[0], res[1], res[2], res[3], res[4]);
    
}

我觉得自己像个白痴，因为能够真正手动分配内存并将其弄得一团糟：/

Answer 1

行

endIdx += 1;

看起来不对，因为它会导致超出范围的访问。

尝试使用

endIdx -= 1;

或

endIdx += -1;

相反。

Answer 2

正如 MikeCAT 所提到的，当您从末尾提取值时，endIdx 应该下降而不是上升。

你的“半合并排序”也有点可疑。考虑数组：

{ 2, 3, 1 }

您的算法将从比较开始和结束开始。 2 > 1，所以它会将 2 放在最后。只有在这之后它才会查看 3。这将最终为：

{ 1, 3, 2 }

I'm also not really clear when, if you pass the pointer back to another function, to free up the used memory from malloc.

作为实现，您的函数分配内存并为调用者创建一个义务，以便在他们使用完它时释放它。这类似于调用“打开”如何为调用者创建稍后调用“关闭”的义务。为了解决这个问题，您的 runSortedSquaredArrayTest 函数应该以 free(res); 结尾。实现这一点的另一种方法是让调用者提供他们想要放置输出的内存。调用时，这可能看起来像：

void sortedSquaredArray(int length, int* input, int* output) {...}
void runSortedSquaredArrayTest()
{
    int input[] = { -4, -1, 0, 3, 10 };
    int output[] = { 0, 0, 0, 0, 0 };

    sortedSquaredArray(5, input, output);
    printf("val1 %d, val2 %d, val3 %d, val4 %d, val5 %d", output[0], output[1], output[2], output[3], output[4]);
    
}

使用这种方法，调用者不需要释放任何东西。

Answer 3

以下建议代码：

干净地编译
执行所需的功能
仅使用标准 C 头文件

现在建议的代码：

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

//from: https://www.programmingsimplified.com/c/source-code/c-program-bubble-sort
void bubbleSort( int *array, size_t n )
{
    for ( size_t c = 0 ; c < n - 1; c++)
    {
        for (size_t d = 0 ; d < n - c - 1; d++)
        {
            if (array[d] > array[d+1]) /* For decreasing order use '<' instead of '>' */
            {
                int swap       = array[d];
                array[d]   = array[d+1];
                array[d+1] = swap;
            }
        }
    }
}


/// <param name="nums">integer array nums</param>
/// <param name="size">Size of array</param>
/// <returns>Sorted and squared array</returns>
int *sortedSquaredArray( int* nums, size_t size )
{
    int *sortedArray = malloc(size * sizeof(int));
    
    if( ! sortedArray )
    { 
        return NULL;
    }

    memcpy( sortedArray, nums, size*sizeof(int) );
    
    bubbleSort( sortedArray, size );
    
    for( size_t i = 0; i<size; i++ )
    {
        sortedArray[i] *= sortedArray[i];
    }

    return sortedArray;
}


/// Run the sortedSquaredArray test
/// </summary>
void runSortedSquaredArrayTest( void )
{
    int nums1[] = { -4, -1, 0, 3, 10 };

    int *res = sortedSquaredArray(nums1, sizeof(nums) / sizeof( int ));
    if( res )
    {
        printf("val1 %d, val2 %d, val3 %d, val4 %d, val5 %d", 
                res[0], res[1], res[2], res[3], res[4]);
        free( res );
    }
}


int main( void )
{
    runSortedSquaredArrayTest();
}

程序的典型运行结果是：

val1 16, val2 1, val3 0, val4 9, val5 100

使用 malloc 创建数组并将其作为函数传递

Using malloc to create and pass array as function

c

malloc