C: Segmentation Fault bei großem Array

Die Frage ist sehr schwer zu beantworten, ohne deinen Code zu kennen. Poste am besten eine kleine, abgespeckte Version des Programms.

Naja, Dir ist schon bewußt, daß das grob überschlagen ca 10MB Speicher braucht ?

Wenn das Array jetzt z.B am Stack gespeichert wird -> i.A ein bissi zu viel.

int x = 16000;
int y = 180;
float positions[x][y];

funktioniert/compiliert so überigens sicher mit keinem C/C++ Compiler.

Entweder dynamsich anlegen, dann ist es sowieso nicht mehr am Stack gespeichert. Und der Code zum Speicherreservieren für das Array mit malloc bzw new ist entscheidend.
Oder const int x= ...
Oder ist positions gar eine Klasse mit überladenem [] Operator ?
Glaub ich nicht, denn [][] ist recht tricky mit Operator overloading hinzubekommen.

Kurzum: Da ist IMHO immer noch zu wenig Code um irgendwas Sinnvolles sagen zu können.

Mfg, LB

Zitat von Kuschelmaus

ich glaub nicht, dass es sinn macht, den code zu posten, da er alleine eh nicht rennt weil das ganze in ein größeres projekt eingebettet ist.

Deswegen hab ich ja gemeint, du sollst ihn abspecken, aber eben so weit, daß du noch ein kleines, lauffähiges Programm hast, das deinen Fehler demonstriert. Also sowas:

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


int main(void)
{
    unsigned int m, n;
    float **array;
    float *data;
    unsigned int i, j;


    if (scanf("%u %u", &m, &n) == 2)
    {
        printf("m = %u, n = %u\n", m, n);
        /* lege großen Speicherblock an */
        data = malloc(m * n * sizeof *data);
        /* lege Array von Pointern an */
        array = malloc(m * sizeof *array);
        if (data == NULL || array == NULL)
        {
            puts("data oder array konnte nicht angelegt werden");
            exit(EXIT_FAILURE);
        }
        /* setze Pointer an den Anfang jeder "Spalte" */
        for (i = 0; i < m; i++)
            array[i] = data + i * n;
        /* teste den Speicher */
        for (i = 0; i < m; i++)
            for (j = 0; j < n; j++)
                array[i][j] = i * n + j;
        puts("alles ok");
        /* gebe Pointer und Gesamtspeicherblock frei */
        free(array);
        free(data);
    }

    return 0;
}

oder auch:

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


int main(void)
{
    unsigned int m, n;
    float **array;
    unsigned int i, j;


    if (scanf("%u %u", &m, &n) == 2)
    {
        printf("m = %u, n = %u\n", m, n);
        /* erste Dimension anlegen: ein Array von Pointern, für die
         * dann jeweils eine Spalte der Matrix angelegt wird */
        array = malloc(m * sizeof *array);
        if (array == NULL)
        {
            puts("array konnte nicht angelegt werden");
            exit(EXIT_FAILURE);
        }
        for (i = 0; i < m; i++)
        {
            /* erzeuge i-te Spalte */
            array[i] = malloc(n * sizeof *array[i]);
            if (array[i] == NULL)
            {
                printf("array[%u] konnte nicht angelegt werden", i);
                exit(EXIT_FAILURE);
            }
            /* weise jedem Element des Arrays einen Wert zu.
             * Eventuelle Probleme sollten spätestens hier
             * auftauchen. */
            for (j = 0; j < n; j++)
                array[i][j] = n * i + j;
        }
        puts("alles ok soweit");
        /* gebe einzelne Spalten frei */
        for (i = 0; i < m; i++)
            free(array[i]);
        /* gebe Spaltenarray frei */
        free(array);
    }

    return 0;
}

Die erste Variante legt dabei einen großen Speicherblock für die gesamte Matrix an und erzeugt dynamisch Pointer, die jeweils an den Anfang einer Spalte zeigen. Die zweite Version legt für jede Spalte ein eigenes dynamisches Array an, hier ist der Speicherblock für die gesamte Datenstruktur nicht zusammenhängend.
Beide funktionieren bei mir tadellos, z.B. mit dem Input "16000 1800". Ob sie wirklich korrekt sind, ist eine andere Sache

Zitat von Lord Binary

int x = 16000;
int y = 180;
float positions[x][y];

funktioniert/compiliert so überigens sicher mit keinem C/C++ Compiler.

Doch: der gcc (3.3.2) compilierts anstandslos, und Segfaults hab ich auch keine bekommen.

Seltsam, aber richtig, gcc 3.2 compiliert das tatsächlich.

Hab' hier ne ältere gcc Version, und da kommt die Fehlermeldung die ich eigentlich erwartet hab: (sinngemäß) ich will x und y konstant !!!

Wär interessant, wie das tatäschlich übersetzt wird.
Speicher dynamisch oder statisch anglegt ?
Egal ... hab im AUgenblick keine Lust auf Assemblercode :]

Zitat von jeuneS2

Doch: der gcc (3.3.2) compilierts anstandslos,

Ihr habt beide halb recht - in C89/90 ist sowas absolut verboten, in C99 ist es unter bestimmten Umständen erlaubt. Ältere oder auf Wachsamkeit konfigurierte gccs melden "y.c:4: error: ISO C90 forbids variable-size array `positions'".

Zitat

und Segfaults hab ich auch keine bekommen.

Reines Glück. 11 MB auf dem Stack sind nicht unbedingt stabilitätsfördernd.

Der Code von Plantschkuh! ist übrigens bis auf ein paar kosmetische Kleinigkeiten sauber.

.