Malloc kompilieren-Fehler: der Wert vom Typ "int" kann nicht verwendet werden, zu initialisieren einer Entität vom Typ int (*)[30]

Diese beiden compile gut für mich. Der erste Fehler ist üblich, wenn Sie vergessen, #include <stdlib.h> vor der Verwendung von Funktionen deklariert gesagt-gleichen (wie malloc(size_t)), was ich auch Tat nicht vergessen.

C hat einige interessante compile-Zeit-Verhalten, unter Ihnen die Fähigkeit, eine Funktion aufzurufen, die noch nie zuvor gesehen hat (weder in der Prototyp-definition noch Umsetzung). Nach der Begegnung mit einem solchen Aufruf, C übernimmt die Funktion ist:

• Etwas zurück int
• Nimmt eine unbekannte Anzahl von Argumenten, so der Anrufer kann passieren was es will (darunter die falschen Dinge).

ZB., die Funktion wird implizit davon ausgegangen, dass von der form:

int func();

Oft werden Sie nicht einmal bemerken, außer für Warnungen von Ihrem compiler, der Bericht etwas zum Effekt von:

Warning: implicit declaration of `func` assumed to return `int`

und wenn Sie on-the-ball, müssen Sie Ihre Warnung Ebenen aufgedreht mit Warnungen als Fehler aktiviert und fangen.

Aber was, wenn Sie nicht? Und was ist, wenn das "Ding" von der Funktion zurückgegeben werden können Inhalte-dargestellt durch die Größe der Daten in einer Implementierung int ? Was ist, wenn zum Beispiel int waren 32-bit, aber die Daten, die Hinweise waren 64-bit? Angenommen char *get_str() deklariert ist in einigen header-Datei, die Sie nicht darunter und umgesetzt .c-Datei, kompilieren Sie und verknüpfen Sie mit Ihrem Programm,, die wie folgt aussieht:

#include <stdio.h>

//Note: NO prototype for get_str
int main()
{
    char *s = get_str();
    printf("String: %s\n", s);
    return 0;
}

Gut, sollte der compiler kotzen, sagen Sie, dass int und char* sind nicht kompatibel (kurz nachdem es warnt Sie get_str wird angenommen, dass die Rückkehr int). Aber was ist, wenn Sie erzwingen, dass der compiler die hand von sagen es um eine char* eine oder andere Weise:

#include <stdio.h>

//Note: NO prototype for get_str
int main()
{
    char *s = (char*)get_str(); //NOTE: added cast
    printf("String: %s\n", s);
    return 0;
}    

Nun, ohne dass Warnungen als Fehler aktiviert, erhalten Sie eine implizite Deklaration Warnung, und das ist es. Der code kompiliert wird. Aber es laufen ? Wenn sizeof(int) != sizeof(char*), (32-bit vs 64-bit) wahrscheinlich nicht. Der zurückgegebene Wert von get_str ist ein 64-bit-Zeiger, aber die Anrufer ist vorausgesetzt, nur 32-bit zurückgegeben wird, dann zwingt es zu einer 64-bit-Zeiger. Kurz gesagt, der cast hat, versteckt Sie den Fehler und öffnete die Büchse der pandora von undefiniertem Verhalten.

Also, wie funktioniert dies alles in Beziehung zu Ihrem code? Durch nicht einschließlich <stdlib.h> der compiler nicht weiß, was malloc ist. Also er meint es ist von der form:

int malloc();

Dann, indem er das Ergebnis auf (int**) sagst du dem compiler "was auch immer dabei heraus kommt, machen es zu einem int**". Zur link-Zeit, _malloc gefunden wird (keine parameter-Signatur über die name manglings wie C++), verdrahtet, und Ihr Programm ist bereit für die party. Aber auf Ihrer Plattform int und Daten Zeiger sind nicht die gleiche Größe, so dass Sie am Ende mit mehrere unerwünschte Folgen:

• Die Besetzung verbirgt sich der wirkliche Fehler.
• Eine falsche Zeiger hergestellt, die von der Hälfte der bits der real zurückgegebene Zeiger.
• Als eine grausame Dosis von Salz auf die Wunde, wird der zugeordnete Speicher wird zugespielt, da gibt es keine gültigen Zeiger überall, die darauf verweisen (Sie hat das einzige zerstört, indem Sie nur die Hälfte).
• Wahrscheinlich die die meisten unerwünscht, den code zu zeigen das normale Verhalten, wenn kompiliert, die auf einer Umsetzung, wo sizeof(int) == sizeof(int**).

So bauen Sie diese auf Ihrem 32-bit-Debian-box, sieht alles gut aus. Sie Ihre Hausaufgaben, um den professor, der baut es auf seinem 64-bit-Mac und es stürzt ab, Sie nicht die Abtretung, nicht die Klasse, fallen aus der Schule und verbringen die nächsten zehn Jahre streicheln der Katze beim beobachten Seinfeld Wiederholungen in Ihrem mom Keller Fragen, was falsch gelaufen ist. Autsch.

Nicht behandeln, casting, wie ein paar silberne Kugel. Das ist es nicht. In C ist es erforderlich weit weniger oft als Menschen, die es verwenden, und wenn Sie in der falschen Ort verstecken können katastrophale Fehler. Wenn Sie einen Punkt in Ihrem code, wo etwas nicht kompilieren, ohne einen harten Wurf, die Blick wieder. Es sei denn, Sie sind sich absolut sicher, dass die Besetzung ist die richtige Sache zu tun, Verschiedenheit seiner falsch.

In diesem Fall versteckte er den wirklichen Fehler, dass Sie es versäumt, geben Sie genug Informationen, um dem compiler zu wissen, was malloc wirklich tut.

InformationsquelleAutor WhozCraig

Zur Zuweisung des array:

int *array = malloc(sizeof(int) * 160 * 10);

Dann verwenden Sie code wie:

array[10 * row + column] = value;

(Wo row geht von 0 bis 159 inclusive und column geht von 0 bis 9 inklusive.)

InformationsquelleAutor David Schwartz

Don ' T mind me, ich bin nur hinzufügen ein Beispiel mit calloc

void allocate_fudging_array(int R, int C)
{
    int **fudging_array = (int **) calloc(R, sizeof(int *));
    for(int k = 0; k < R; k++)
    {
        fudging_array[k] = (int*) calloc(C, sizeof(int));
    }
}


//a helper function to print the array 
void print2darr(int **arr, int R, int C)
{
    for(int i = 0; i < R; i++)
    {
        for(int j = 0; j < C; j++)
        {
            printf(" %d  ", arr[i][j]);
        }
        printf("\n");
    }
}

InformationsquelleAutor Reno