ich brauche dringend Hilfe. Folgendes Programm gibt mir einen Segmentation Fault:

#include<string>
int main()
{
        N=2028;
        double b[N][N];
        std::string name;
}

Falls ich N viel kleiner wähle (z.B. N=10) ist alles in Ordnung.
Das ist doch eigentlich nicht möglich, oder?!

Ich habe es mit 4 verschiedenen Rechnern und mehreren Versionen des g++ Compilers versucht. So wie's aussieht tritt der Fehler nur bei Ubuntu und Debian auf. Bei Suse nicht.

Vielen Dank.

Tobias

was ist N??

Viel zu groß.

TobiasStollenwerk, dein Array passt nicht auf den Stack.

#include<string>
int main()
{
        int N=2028;
        double b[N][N];
        std::string name;
}

Erstmal danke für die Antworten.
Ich weiss zwar nicht was ein "Stack" ist, aber ich denke mal, dass ich das Problem mit mit Speicher allokieren lösen kann, oder?

Falls ja, wie mach ich das genau? Ich brauche nämlich eigentlich ein 4-Dimensionales array:

#include<string>
int main()
{
        int N=16;
        double b[N][N][N][N];
        std::string name;
}

Und Außerdem, warum funktioniert es dann bei kleinen N? Dort habe ich ja auch keinen Speicher allokiert.

Tobias

#include<string>
#include<iostream>
int main()
{
        int N=16;
        double**** bl = new double*** [N];
        for (int i=0; i!=N; i++)
        {
                bl[i]=new double**[N];
        }

        for (int i=0; i!=N; i++)
        {
                for (int j=0; j!=N; j++)
                {
                        bl[i][j] = new double*[N];
                }
        }

        for (int i=0; i!=N; i++)
        {
                for (int j=0; j!=N; j++)
                {
                        for (int k=0; k!=N; k++)
                        {
                                bl[i][j][k]=new double;
                        }
                }
        }
}

Aber warum es für kleine N auch so geht weiss ich immer noch nicht...

Vielen Dank!!!

Tobi

Und ja du könntest das wohl per dynamische allokation lösen:

int main()
{
    double * d = new double[2048][2048];
}

Allersings musst du dich dann auch manuell um die freigabe kümmern. Du kannst auch vector verwenden:

#include <vector>
int main()
{
    std::vector<std::vector<double> > vec;
}

Mit dem Vorteil dass dieser eine dynamische Größe hat und sich selbst um die freigabe kümmert.

#include <vector>
int main()
{
    std::vector< std::vector< std::vector< std::vector<double> > > > vec;
}

für das 4D-Array. allerdings währe dann hier wohl die frage ob man nicht mit weniger dimensionen auskommt.

EDIT://
Das erste kompilert irgendwie nicht. Muss irgendwie anders sein

Und Außerdem, warum funktioniert es dann bei kleinen N? Dort habe ich ja auch keinen Speicher allokiert.

es sind immer N*N*8 Bytes. Also bei N=10 nur 10*10*8 während bei N = 2028 2028*2028*8 Bytes

|C^2 oder |R^4?

Soll N später zur Laufzeit festzulegen sein?

Falls nicht kannst Du Dir die Sache vielleicht einfache machen indem Du N und b vor main, also global, deklarierst. Mit mingw konnte ich sowohl Deinen Fehler reproduzieren als auch mittels der globalen Deklaration abstellen.
Dann kan der Compiler die Variable besser plazieren (vereinfacht gesagt); und Du erspart Dir viel Code und "double****".

Grüsse

*this

Das erste kompilert irgendwie nicht. Muss irgendwie anders sein

Ein new[][] gibt es auch nicht

darthdespotism schrieb:

Das erste kompilert irgendwie nicht. Muss irgendwie anders sein

Ein new[][] gibt es auch nicht

braucht er auch nicht:

double (*d)[2048] = new double[2048][2048];

mit typedef wird deutlich, warum:

typedef double T[2048];
T* d = new T[2048];

ist völlig äquivalent

Ich werde wohl mit new arbeiten müssen...

Nochmal Vielen Dank an alle.

Tobias

double a[10][20];

schreibst. Wenn das geht geht es mit std::vector auch:

...
{
    std::vector<double> a(10*20);
    irgendwas(&(a[0]), 10, 20);
}

Also einer von uns beiden steht zumindest auf der Leitung...