ist das normal, dass Segmentation Faults entstehen, wenn die lokalen Variablen einer Funktion zuviel Speicher einnehmen? In einem anderen Programm konnte ich sogar im Debugger beobachten, dass dadurch Konstanten (!!) verändert wurden.

Ich habe in letzter Zeit schon ein wenig in Assembler programmiert und weiss daher, dass lokale Variablen einer Funktion (unter Linux) auf dem Stack landen... Daher glaube ich, dass der Stack evtl. zu weit nach oben wächst und dann irgendwas überschreibt... aber sollte dem Compiler sowas nicht auffallen? Immerhin ist die lokale arr-Variable von fester Größe.

ich habe folgendes Testprogramm gebastelt, um das Problem zu veranschaulichen:

#include <iostream>
#include <cassert>

using namespace std;

double c1 = 1;
double c2 = 2;
double c3 = 3;
double c4 = 4;
double c5 = 5;
double c6 = 6;
double c7 = 7;
double c8 = 8;
double c9 = 9;
double c10 = 10;

void test()
{
	double arr[300][300][300];

        // Segmenatation Fault ?!... aber nur wenn Variable arr zuviel Speicher belegt :D
	cout << c1 << ", " << c2 << ", " << c3 << ", " << c4 
	<< ", " << c5 << ", " << c6 << ", " << c7 << ", " << c8 
	<< ", " << c9 << ", " << c10 << endl;

	assert(c1 == 1);
	assert(c2 == 2);
	assert(c3 == 3);
	assert(c4 == 4);
	assert(c5 == 5);
	assert(c6 == 6);
	assert(c7 == 7);
	assert(c8 == 8);
	assert(c9 == 9);
	assert(c10 == 10);
}

int main(int argc, char* argv[])
{
	test();
}

Ist der einzige Ausweg in diesem Fall wirklich nur ein dynamisches Array?

double arr[300][300][300];

Ich habe ein großes Programm, was mal jmd. geschrieben hat, welches derart große Arrays verwendet hat... Das lief auch so auf einem Cluster mit 64 Bit.

Bei Wechsel der plattform auf "Normalrechner" machen diese großen Arrays nun Probleme und ich muss offenbar zusehen, dass der ganze Kram nun dynamisch alloziiert wird

Ich habe ein großes Programm, was mal jmd. geschrieben hat, welches derart große Arrays verwendet hat...

Ich frag jetzt nicht, wie man auf solche Ideen kommt...

Das hat nicht einmal was mit dem Programm an sich zu tun. Unter Linux zB einfach mit ulimit -s <LIMIT> die gewünschte Stackgröße setzen.

Danke! Das hat definitiv gepasst Die alte Grenze des Stacks stand auf 8 MB, was in etwa zu meinen Beobachtungen passt. Stell ich das auf > ~205Mb dann läuft obiges Programm ohne Fehler durch.

Können mir durch eine zu eine hohe Stack-Grenze irgendwelche Nachteile entstehen? Bleibt dann generell weniger Platz für dynamisch alloziierten Speicher oder erst, wenn der Stack tatsächlich so groß wird?