指针和分配在函数或静态变量和内部分配？

Question

不要害怕我的帖子的长度,它很简单,我只是不知道如何把它更短:

我有两种方法可以做一些非常类似于通过函数合并两个数组的方法.我在这里调用该函数combine_data().该阵列称为data1和data2.假设我的数组如下:

int num1 = 4;
int num2 = 6;

double data1[num1] = /* some values */
double data2[mum2] = /* some values */

解决方案1

我可以使用我发现更优雅的解决方案,但我不确定这是不是很好的做法,并且行为正常.该解决方案依赖于旨在使数组持久化的静态变量.不知怎的,感觉它可能会以某种方式在我的脸上爆炸.

// SOLUTION 1
double* combine_data(
    const int num1, const double* const data1,
    const int num2, const double* const data2
) {
    int i;
    int num = num1 + num2;
    double *combi;   // static because the data stored the should persist
    combi = (double*)malloc( num*sizeof(*combi) );
    /* some code */
    for(i=0; i<num1; ++i)   combi[i] = data[i];
    for(i=num1; i<num; ++i) combi[i] = data[i];

    return combi;
}

double *combi = combine_data(num1, data1, num2, data2);
/* some code */
free(combi);    // problem with free of a static variable in combine_data() ???

解决方案2

或者我可以使用我更习惯的方法,它使用指针来实现相同的功能:

// SOLUTION 2
void combine_data(
    const int num1, const double* const data1,
    const int num2, const double* const data2
    double* combi
) {
    /* some code */
    for(i=0; i<num1; ++i)   combi[i] = data[i];
    for(i=num1; i<num; ++i) combi[i] = data[i];
}

int num = num1 + num2;
double *combi = (double*)malloc( num*sizeof(combi) );
combine_data(num1, data1, num2, data2, combi);
/* some code */
free(combi);

解决方案2的问题是没有任何东西可以阻止用户:combine_data(num1, data1, num2, data2, data1)这会搞砸data1.解决方案2隐藏了分配,并且更容易使用,我发现它更优雅,但我不知道它在释放内存时会如何表现.哪种解决方案最好,为什么？

顺便说一句.两者之间有区别吗？:

const int* const name
const int const *name

编辑:一个真的是我在错误的代码中看到的语法错误,并想知道.也放弃了static.

Answer 1

为什么需要combi在解决方案 1 中将其设为静态？指针不必持续存在，只要它所指向的内容就可以。然后按值返回指针，因此不会发生内存泄漏。

您选择哪种解决方案完全取决于您对整个程序风格的假设。您必须决定该函数是否应该分配并返回指向已分配内存的指针，或者接受指向已分配内存的指针。

两种解决方案都是正确的，并且在我看来同样好。在解决方案 2 中，您还可以检查输入和输出指针之间是否相等并返回错误代码。您甚至可以检查内存重叠，而不仅仅是指针相等性。但话又说回来，这完全取决于您为程序的不同部分分配的职责。