Ich konnte erfolgreich mit Arrays variabler Länge in @ arbeitC und ich habe jetzt folgendes:

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

int (*foo(size_t row, size_t col))[3];

int main(void){
    size_t row, col;


    printf("Give the ROW: ");
    if ( scanf("%zu",&row) != 1){
        printf("Error, scanf ROW\n");
        exit(1);
    }

    printf("Give the COL: ");
    if ( scanf("%zu",&col) != 1){
        printf("Error, scanf COL\n");
        exit(2);
    }

    int (*arr)[col] = foo(row, col);

    for ( size_t i = 0; i < row; i++){
        for( size_t j = 0; j < col; j++){
            printf("%d ",*(*(arr+i)+j));
        }
    }

    free(arr);
}


int (*foo(size_t row, size_t col))[3]{
    int (*arr)[col] = malloc(row * col * sizeof(int));
    int l=0;

    if (arr == NULL){
        printf("Error, malloc\n");
        exit(3);
    }

    for ( size_t i = 0; i < row; i++){
        for( size_t j = 0; j < col; j++){
            *(*(arr+i)+j) = l;
            l++;
        }
    }

    return arr;
}

Ausgabe

Give the ROW: 2
Give the COL: 5
0 1 2 3 4 5 6 7 8 9

Jetzt das

int (*foo(size_t row, size_t col))[3]{ /* code */ }

bedeutet, wenn ich richtig verstanden habe, dass foo als eine Funktion mit zwei Parametern deklariert (size_t row, size_t col), die einen Zeiger auf ein Array 3 von int zurückgibt.

Ich bin nicht in der Lage, diese Art von Funktion zu verstehen, und es ist komplizierter für mich, jetzt mit Arrays variabler Länge zu arbeiten, wenn die Größe nur zur Laufzeit bekannt ist, aber ich finde das eine gute Sache. Ich arbeite nur mitC11 standard.

uf jeden Fall hierint (*foo(size_t row, size_t col))[3] Ich habe diese [3] die mir nicht klar ist wie es funktioniert und wie ich es zur laufzeit möglich machen kann (natürlich nur wenn es möglich ist), sowas wieint (*foo(size_t row, size_t col))[SIZE].

Ich las einige Bücher überC, aber es gibt keine genauen Erklärungen zu dieser Situation und Google hilft auch nicht. Daher habe ich zwei Fragen:

1) Ist das möglichint (*foo(size_t row, size_t col))[SIZE], wo muss GRÖSSE der Parameter sein? Oder soll ich diese Funktion anders deklarieren?

2) Ist das der richtige Weg für das, was ich hier ausprobiert habe, oder gibt es eine andere Alternative?

Ich versuche nur, einen Zeiger auf ein Array zurückzugeben, dessen Größe zur Laufzeit bekannt ist und nicht zur Kompilierungszeit. Der Aufruf vonmalloc undfree kommt nur einmal vor und das ist ein guter Ansatz, denn wann immermalloc wird aufgerufen, unser Programm stört den Kernel, um Speicher zuzuweisen und die Seite als beschreibbar zu markierekernel. Es kann in einem @ geschrieben werdmalloc Arbeiten mit VLAs

BEARBEITEN

@ ChronoKitsune sagte, ich sollte / try[] (Array mit nicht angegebener Größe) In diesem Fall sieht die Funktion folgendermaßen aus:

int (*foo(size_t row, size_t col))[]{ /* code */ }

Ist das was ich benutzen soll?