Malloc双指针

我的函数原型应该如下所示：

void double_min_max(int **range, int min, int max)

size_t double_min_max(int **range, int min, int max)
{
    // check for valid input
    if (min > max) return 0;

    // calculate required size
    size_t size = max - min + 1;

    *range = malloc(size * sizeof **range);

    // check allocation succeeded:
    if (!*range) return 0;

    for (size_t i = 0; i < size; ++i)
    {
        (*range)[i] = min++;
    }
    return size;
}

int *range;
size_t result = double_min_max(&range, 10, 20);

// result should now be 11, the size of the array `range` points to

// when done:
free(range);

我必须用从最小到最大的数字填充“范围”

我不知道如何malloc双指针，以及如何为每个元素分配最小值

void    double_min_max(int **range, int min, int max)
{
    range = (int **)malloc(sizeof(int)* 10);
    int i = 0;
        while (min < max)
        {
        **range[i] = min;
        i++;
        min++;
    }
}

void double\u min\u max（int**range，int min，int max）
{
范围=（int**）malloc（sizeof（int）*10）；
int i=0；
同时（最小值<最大值）
{
**范围[i]=min；
i++；
min++；
}
}

好的，让我们找出错误：

void double_min_max(int **range, int min, int max)
{
    range = (int **)malloc(sizeof(int)* 10);

malloc的演员阵容是不必要的，甚至有可能。不要这样做

然后您要分配给

*范围

，而不是

范围

<代码>范围是函数的局部变量（所有参数都是通过C中的值传递的），因此修改它将永远不会对调用代码产生任何可见的效果。调用此函数时，应将指针传递给指针，以便该函数可以通过

*range

修改指针

最后，这应该是显而易见的，但是您应该从

min

和

max

计算所需的大小。

10

只是一个。。。嗯。。。非常粗略的猜测。这不是个好主意

    int i = 0;
        while (min < max)
        {
        **range[i] = min;

合理的实现可能如下所示：

void double_min_max(int **range, int min, int max)

size_t double_min_max(int **range, int min, int max)
{
    // check for valid input
    if (min > max) return 0;

    // calculate required size
    size_t size = max - min + 1;

    *range = malloc(size * sizeof **range);

    // check allocation succeeded:
    if (!*range) return 0;

    for (size_t i = 0; i < size; ++i)
    {
        (*range)[i] = min++;
    }
    return size;
}

int *range;
size_t result = double_min_max(&range, 10, 20);

// result should now be 11, the size of the array `range` points to

// when done:
free(range);

---

使用

**range=malloc…

，您实际上可以访问/分配“指向int的指针”（这是

int**range

表示的）指向的第一个整数值。 这应该是

*range=malloc…

。此外，

**range[i]

是非法的，因为

**range

是一个整数值，而不是数组或指针，因此

**range[i]=min

取消了对整数值的引用（在此上下文中，这是非法/未定义的行为）。它应该是

*范围[i]=min

因此，完整的代码（包括一些必要的检查）、函数的使用以及结果的使用可以如下所示：

int double_min_max(int **range, int min, int max) {

    // range is a pointer PPI to a pointer PI pointing to one (or more consecutive) integers I
    // *range is the "value" of PI, i.e. the pointer to the memory block representing the sequence of integers

    if (min >= max)  // check if the range is valid
        return 0;

    if (!range) // check if you may assign a value to *range
        return 0;

    int size = max - min;
    int *intArray = malloc(size * sizeof(int));
    if (!intArray) // did malloc fail?
        return 0;

    // fill the range
    for (int i=0; i<size; i++) {
        intArray[i] = min+i;
    }

    // let *range point to the malloced and filled array
    *range = intArray;

    // return the size of the array.
    return size;
}

int main() {

    int *myRange = NULL;
    int size = double_min_max(&myRange, -30, -10);

    if (size && myRange) {
        for (int i=0; i<size; i++) {
            printf("%d ", myRange[i]);
        }
        free(myRange);
    }
    return 0;
}

int-double\u-min\u-max（int**range，int-min，int-max）{
//范围是指向指向一个（或多个连续）整数I的指针PI的指针PPI
//*范围是PI的“值”，即指向表示整数序列的内存块的指针
if（min>=max）//检查范围是否有效
返回0；
if（！range）//检查是否可以为*range赋值
返回0；
int size=max-min；
int*intArray=malloc（size*sizeof（int））；
如果（！intArray）//malloc失败了吗？
返回0；
//满量程
对于（int i=0；irange=（int**）malloc（sizeof（max-min）），这里没有人会为您编写代码。如果您访问www.google.com并键入问题的标题，“malloc双指针”，有很多关于分配部分的例子。通过这个声明，您应该从调用代码传递一个指针。然后只需执行
size\u t size=max-min+1；*range=malloc（size*sizeof**range）；
i变量的用途是什么，为什么是*10？就像它应该是
*range[i]=anitvalue
。我认为这会误导OP.@BLUEPIXY:Uups，谢谢！