Question

Consider the following functions
void alloco(int **ppa)
{
    int i;
    printf("inside alloco %d\n",ppa); /*this function allocates and fills 20 * sizeof(int) bytes */
    *ppa = (int *)malloc(20 * sizeof(int));
    /*fill all 20 * sizeof(int) bytes */
}

int main()
{
    int *app = NULL;
    int i;
    printf("inside main\n");
    alloco(&app);
    for(i=0;i<20;i++) /*ISSUE::how will i know to traverse only 20 indexes?*/
    printf("app[%d] = %d \n", i, app[i]);
    return(0);
}

基本上main（）如何知道遍历的字节数，即alloco（）函数分配的内存。在字符数组中是否有像NULL这样的分隔符？

Answer 1

这是不可能的，你需要在某个地方保留这个值，例如你可以这样做，

void alloco(int **ppa, int count)
{
    int i;

    printf("inside alloco %d\n",ppa);
    *ppa = malloc(count * sizeof(int));
    if (*ppa == NULL)
        return;
    for (i = 0 ; i < count ; ++i)
        /* fill it here. */
}

int main()
{
    int *app;
    int  i;
    int  count;

    count = 20;
    app = NULL;
    printf("Inside main\n");
    alloco(&app, count);
    if (app == NULL)
        return -1;    
    for (i = 0 ; i < count ; i++)
        printf("app[%d] = %d \n", i, app[i]);
    /* done with `app' */
    free(app);
    return 0;
}

许多其他组合可以起作用，例如

int alloco(int **ppa)
{
    int i;

    printf("inside alloco %d\n",ppa);
    *ppa = malloc(20 * sizeof(int));
    if (*ppa == NULL)
        return;
    for (i = 0 ; i < count ; ++i)
        /* fill it here. */
    return 20;
}

int main()
{
    int *app;
    int  i;
    int  count;

    printf("Inside main\n");

    app = NULL;
    count = alloco(&app);
    if (app == NULL)
        return -1;    
    for (i = 0 ; i < count ; i++)
        printf("app[%d] = %d \n", i, app[i]);
    /* done with `app' */
    free(app);
    return 0;
}

但我个人不喜欢这样，因为如果有一个固定数目的整数，那么使用malloc()就不是一个好主意，

int main()
{
    int  app[20];
    int  i;

    printf("Inside main\n");    
    for (i = 0 ; i < sizeof(app) / sizeof(app[0]) ; i++)
        printf("app[%d] = %d \n", i, app[i]);
    return 0;
}

Answer 2

字符数组中是否有像NUL L 这样的分隔符？

如果你定义一个，是的。

但是，只有在您的用例不需要所有可能的整数值时才可以这样做。

例如，如果您只需要包含0的正值，则可以将-1的值定义为＆＃34;数组结束＆＃34;标记。

然后，您需要再为该数组分配一个元素，并将-1分配给这个额外的最后一个数组元素。

示例：

#include <stdlib.h> /* for malloc */ #include <errno.h> /* for errno */ #define EOA (-1) int array_allocate(int ** ppi) { int result = 0; if (NULL = ppi) { result = -1; errno = EINVAL; } else { size_t number_of_elements = ...; /* Assign some positive value here. */ *ppi = malloc((number_of_elements + 1) * sizeof ** ppi); if (NULL == *ppi) { result = -1; } else { (*ppi)[number_of_elements] = EOA; } } return result; } ssize_t array_number_of_elements(int * pi) { int result = 0; if (NULL == pi) { result = -1; errno = EINVAL; } else { int * pi_tmp = pi; while (EOA != *pi_tmp) { ++pi_tmp; } result = pi_tmp - pi; } return result; }

像这样使用：

#include <stdlib.h> /* for size_t and ssize_t */ #include <stdio.h> /* for printf and perror */ int array_allocate(int **); ssize_t array_number_of_elements(int *); int main(void) { int result = EXIT_SUCCESS; int * pi = NULL; if (-1 == array_allocate(&pi)) { result = EXIT_FAILURE; perror("array_allocate() failed"); } else { ssize_t result_number_of_elements = array_number_of_elements(pi); if (-1 == result_number_of_elements) { result = EXIT_FAILURE; perror("array_number_of_elements() failed"); } else { size_t number_of_elements = result_number_of_elements; printf("The number of array's elements is %zu.\n", number_of_elements); } } free(pi); /* Clean up. */ return result; }

Answer 3

成为一名三星级程序员

您可以轻松地在函数中分配一些固定数量的元素（小于最大值），而无需传递调用函数和被调用者之间的元素数。但是，需要创建一个指向指针的指针数组如何/为什么？实际上，您将数组视为以空字符结尾的字符串，最初将所有指向数组的指针分配给NULL，并根据需要仅为它们分配空间。（使用calloc进行分配会使其变得简单）当数组在调用者中使用时，它允许迭代所有填充的值，直到达到第一个空指针。

现已获批，

只需将指针大小作为附加参数传递给您功能更有意义[1]

并且无需三星评级，但出于举例的目的，您可以暂时成为三星级程序员：

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

#define INITSZ 21

void alloco (int ***ppa)
{
    printf("inside %s\n", __func__);

    int i = 0;

    /* allocate 21 pointers-to-int */
    if (!(*ppa = calloc (INITSZ, sizeof **ppa))) {
        fprintf (stderr, "%s() error: virtual memory exhausted.\n", __func__);
        exit (EXIT_FAILURE);
    }

    /* allocate/fill 20 values (or anything less than 21) */
    for (i = 0; i < INITSZ - 1; i++) {
        if (!((*ppa)[i] = calloc (1, sizeof ***ppa))) {
            fprintf (stderr, "%s() error: virtual memory exhausted.\n", __func__);
            exit (EXIT_FAILURE);
        }
        *((*ppa)[i]) = i * 2;
    }
}

int main()
{
    int **app = NULL;
    int i = 0;

    printf ("inside main\n");
    alloco (&app);

    /*ISSUE::how will i know to traverse only 20 indexes?*/

    while (app[i]) {
        printf("app[%d] = %d \n", i, *(app[i]));
        i++;
    }

    return(0);
}

使用/输出

$ ./bin/alloc_array+1 inside main inside alloco app[0] = 0 app[1] = 2 app[2] = 4 app[3] = 6 app[4] = 8 app[5] = 10 app[6] = 12 app[7] = 14 app[8] = 16 app[9] = 18 app[10] = 20 app[11] = 22 app[12] = 24 app[13] = 26 app[14] = 28 app[15] = 30 app[16] = 32 app[17] = 34 app[18] = 36 app[19] = 38

脚注[1]：重点添加到引文中，以明确该解决方案旨在展示可能的内容，而不是最有效或最实用的内容。

整数/结构数组的结尾？

3 个答案: