c - 在 C 中，使用变量初始化数组会导致堆栈溢出错误或在 R 中调用代码时导致 R 崩溃

Question

好的。我原来的问题原来是由于没有初始化一些数组引起的。最初的问题与代码崩溃 R 有关。当我试图通过注释掉它来调试它时，我错误地注释掉了初始化数组的行。所以我认为我的问题与传递指针有关。

实际问题是这样的。正如我之前所说，我想使用 outer_pos 来计算外部差异并将结果指针和正差异总数传递回调用 outer_pos 的函数

#include <R.h>
#include <Rmath.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>


void outer_pos(double *x, double *y, int *n, double *output){
    int i, j, l=0;
    for(i=0; i<*n; i++){
        for(j=0; j<*n; j++){
            if((x[j]-x[i])>0){
                output[l+1]=(y[j]-y[i])/(x[j]-x[i]);
                output[0]=(double)(++l);
            }
        }
    } 
    Rprintf("%d\n", (int)output[0]);
}


void foo1(double *x, double *y, int *nsamp){
    int i, j, k, oper=2, l;
    double* v1v2=malloc(sizeof(double)*((*nsamp)*(*nsamp-1)/2 + 1));

    outer_pos(x, y, nsamp, &v1v2[0]);
    double v1v2b[1999000];    // <--------------HERE
    for(i=1; i<= (int)v1v2[0]; i++){
        v1v2b[i-1]=1;
    }
}

假设foo1 是调用outer_pos 的函数。此处我使用实际数字 1999000 指定了数组 v1v2b 的大小。该值对应于正差的数量。从 R 调用 foo1 没有问题。一切都很好。

在上面的场景中，我知道正差的数量，所以我可以使用实际值来设置数组大小。但我想适应我不一定知道值(value)的情况。下面的 foo2 就是为了做到这一点。如您所见，v1v2b 使用数组 v1v2 的第一个值进行初始化。回想一下，outer_pos 输出的第一个槽存储正差的数量。所以基本上我使用这个值来设置 v1v2 的大小。但是，在 R 中调用此函数会导致 R 显示堆栈溢出错误或导致其崩溃(请参见下面的屏幕截图)

void foo2(double *x, double *y, int *nsamp){
    int i, j, k, oper=2, l;
    double* v1v2=malloc(sizeof(double)*((*nsamp)*(*nsamp-1)/2 + 1));

    outer_pos(x, y, nsamp, &v1v2[0]);
    double v1v2b[(int)v1v2[0]];        //<--------HERE
    for(i=1; i<= (int)v1v2[0]; i++){
        v1v2b[i-1]=1;
    }
}

所以我想，也许这与索引有关。也许 v1v2b 的实际大小太小，或者其他原因，所以循环在边界之外迭代。所以我创建了 foo2b 并在其中注释掉了循环，并使用 Rprintf 打印了 v1v2 的第一个槽位以查看值是否存储在它是正确的。但是似乎值v1v2[0]是正确的，即1999000。所以我不知道这里发生了什么。

很抱歉让我之前的问题感到困惑!!

void foo2b(double *x, double *y, int *nsamp){
        int i, j, k, oper=2, l;
        double* v1v2=malloc(sizeof(double)*((*nsamp)*(*nsamp-1)/2 + 1));

        outer_pos(x, y, nsamp, &v1v2[0]);
        double v1v2b[(int)v1v2[0]];         //<----Array size declared by a variable
       Rprintf("%d", (int)v1v2[0]);
        //for(i=1; i<= (int)v1v2[0]; i++){
            //v1v2b[i-1]=v1v2[i];
        //}
}

运行上面代码的R代码:

x=rnorm(2000)
y=rnorm(2000)
.C("foo1", x=as.double(x), y=as.double(y), nsamp=as.integer(2000))
.C("foo2", x=as.double(x), y=as.double(y), nsamp=as.integer(2000))
.C("foo2b", x=as.double(x), y=as.double(y), nsamp=as.integer(2000))

** 跟进 **

我根据 Martin 的建议修改了我的代码，以检查是否可以解决堆栈溢出问题:

void foo2b(double *x, double *y, int *nsamp) {
    int n = *nsamp, i;
    double *v1v2, *v1v2b;

    v1v2 = (double *) R_alloc(n * (n - 1) / 2 + 1, sizeof(double));
    /* outer_pos(x, y, nsamp, v1v2); */
    v1v2b = (double *) R_alloc((size_t) v1v2[0], sizeof(int));
    for(i=0; i< (int)v1v2[0]; i++){
        v1v2b[i]=1;
    }
    //qsort(v1v2b, (size_t) v1v2[0], sizeof(double), mycompare);
    /* ... */
}

编译后，我运行了代码:

x=rnorm(1000)
y=rnorm(1000)
.C("foo2b", x=as.double(x), y=as.double(y), nsamp=as.integer(length(x)))

然后得到一条错误信息: 错误:无法分配大小为 34359738368.0 Gb 的内存块

** 跟进 2 **

错误消息似乎每隔一段时间就会出现一次。至少它没有使 R 崩溃...所以基本上功能在正常运行和显示错误消息之间交替。 (我在脚本文件中包含了两个 header )。

Answer 1

和以前一样，您在堆栈上进行分配，但应该从堆中进行分配。像您在上一个问题中所做的那样使用 malloc/free 更正此问题(实际上，我认为推荐的方法是 Calloc/Free 或者如果您的代码返回到 R 只是 R_alloc；R_alloc 会在返回到 R 时自动恢复内存，即使在R 捕获的错误)。

qsort 在评论中提到。它把一个用户提供的函数作为它的最后一个参数，这个函数定义了它的第一个参数是如何排序的。 qsort 的签名(来自man qsort)是

void qsort(void *base, size_t nmemb, size_t size,
           int(*compar)(const void *, const void *));

最后一个参数是“指向一个函数的指针，该函数采用两个常量 void 指针并返回一个 int”。满足此签名并根据手册页上的规范对指向两个 double 的指针进行排序的函数是

int mycompare(const void *p1, const void *p2)
{
    const double d1 = *(const double *) p1,
                 d2 = *(const double *) p2;
    return d1 < d2 ? -1 : (d2 > d1 ? 1 : 0);
}

所以

#include <Rdefines.h>
#include <stdlib.h>

int mycompare(const void *p1, const void *p2)
{
    const double d1 = *(const double *) p1,
                 d2 = *(const double *) p2;
    return d1 < d2 ? -1 : (d2 > d1 ? 1 : 0);
}

void outer_pos(double *x, double *y, int *n, double *output){
    int i, j, l = 0;
    for (i = 0; i < *n; i++) {
        for (j = 0; j < *n; j++) {
            if ((x[j] - x[i]) > 0) {
                output[l + 1] = (y[j] - y[i]) / (x[j] - x[i]);
                output[0] = (double)(++l);
            }
        }
    } 
}

void foo2b(double *x, double *y, int *nsamp) {
    int n = *nsamp;
    double *v1v2, *v1v2b;

    v1v2 = (double *) R_alloc(n * (n - 1) / 2 + 1, sizeof(double));
    outer_pos(x, y, nsamp, v1v2);
    v1v2b = (double *) R_alloc((size_t) v1v2[0], sizeof(double));
    qsort(v1v2b, (size_t) v1v2[0], sizeof(double), mycompare);
    /* ... */
}