Passing dynamisch zugewiesenen ganzzahligen Arrays in C

Question

las ich das Beispiel auf „ Passing multidimensionalen Arrays in C "auf dieser Seite.

Es ist ein großartiges Beispiel char-Arrays verwenden, und ich lernte von ihm eine Menge. Ich möchte, das Gleiche tun, indem eine Funktion, die Schaffung eines dynamisch zugewiesenen eindimensionales Integer-Array zu handhaben, und danach, schaffen eine weitere Funktion ein mehrdimensionales Integer-Array für die Handhabung. Ich weiß, wie es als Rückgabewert eine Funktion zu tun. Aber in dieser Anwendung muss ich es auf der Liste der Argumente an die Funktion tun.

Genau wie im Beispiel I oben erwähnt, würde Ich mag einen Zeiger auf ein ganzzahliges Array an eine Funktion zu übergeben, zusammen mit der Anzahl der Elemente „num“ (bzw. „Zeile“ und „Spalte“ für eine 2D-Array-Funktion , usw.). Ich habe eine überarbeitete Version des anderen Beispiels hier, aber ich kann das nicht an der Arbeit, versuchen, so könnte ich (Codezeilen, die neu sind oder geändert werden, aus diesem Beispiel) gekennzeichnet sind. Wer weiß, wie diese zu lösen?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ELEMENTS 5
void make(char **array, int **arrayInt, int *array_size) { 
    int i;
    char *t = "Hello, World!";
    int s = 10; // new
    array = malloc(ELEMENTS * sizeof(char *));
    *arrayInt = malloc(ELEMENTS * sizeof(int *));  // new
    for (i = 0; i < ELEMENTS; ++i) {
        array[i] = malloc(strlen(t) + 1 * sizeof(char));
        array[i] = StrDup(t);
        arrayInt[i] = malloc( sizeof(int)); // new
        *arrayInt[i] = i * s; // new
    }
}
int main(int argc, char **argv) {
    char **array;
    int  *arrayInt1D; // new
    int size;
    int i;
    make(array, &arrayInt1D, &size); // mod
    for (i = 0; i < size; ++i) {
        printf("%s and %d\n", array[i], arrayInt1D[i]); // mod
    }
    return 0;
}

Answer 1

Es gibt eine ganze Menge von Fragen in diesem Code. Werfen Sie einen Blick auf die folgenden:

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

#define ELEMENTS 5

/*
 * A string is an array of characters, say char c[]. Since we will be creating
 * an array of those, that becomes char *(c[]). And since we want to store the
 * memory we allocate somewhere, we must be given a pointer. Hence char
 * **(c[]).
 *
 * An int doesn't require a complete array, just int i. An array of those is
 * int i[]. A pointer to those is then int *(i[]).
 */
void
make(char **(chars[]), int *(ints[]), size_t len)
{
    static char hw[] = "Hello, World!";
    size_t i = 0;

    /*
     * Allocate the memory required to store the addresses of len char arrays.
     * And allocate the memory required to store len ints.
     */
    *chars = malloc(len * sizeof(char *));
    *ints = malloc(len * sizeof(int));

    /* Fill each element in the array... */
    for (i = 0; i < ELEMENTS; i++) {
        /* ... with a *new copy* of "Hello world". strdup calls malloc under
         * the hood! */
        (*chars)[i] = strdup(hw);
        /* ...with a multiple of 10. */
        (*ints)[i] = i * 10;
    }
}

int
main(void)
{
    /* A string c is a character array, hence char c[] or equivalently char *c.
     * We want an array of those, hence char **c. */
    char **chars = NULL;
    /* An array of ints. */
    int *ints = NULL;
    size_t i = 0;

    /* Pass *the addresses* of the chars and ints arrays, so that they can be
     * initialized. */
    make(&chars, &ints, ELEMENTS);
    for (i = 0; i < ELEMENTS; ++i) {
        printf("%s and %d\n", chars[i], ints[i]);
        /* Don't forget to free the memory allocated by strdup. */
        free(chars[i]);
    }

    /* Free the arrays themselves. */
    free(ints);
    free(chars);

    return EXIT_SUCCESS;
}

Answer 2

Sie fehlen Größe einer Zeile hier:

arrayInt[i] = malloc( sizeof(int)); // new

sollte so etwas wie:

arrayInt[i] = malloc( row_len * sizeof(int)); // new

Dabei gilt, bevor Sie Länge gegebenen Zeichenfolge als Zeilengröße wurden unter Verwendung von (auch sollte strlen(t)+1 in Klammern sein, obwohl der Effekt der gleiche ist, weil sizeof(char) 1)