Maximale Arraygröße?

Ich habe folgende Code geschrieben:

#ifndef FACTORIALDATA_H_
#define FACTORIALDATA_H_

#include <string>

class FactorialData {

	public:
	static const int factorialStepSize = 20000;
	double factorials[100000];
	FactorialData();
	double str2double(const std::string &str);

};

#endif /* FACTORIALDATA_H_ */

Und die CPP-Datei

#include "FactorialData.h"

#include <fstream>
#include <sstream>
#include <iostream>

using namespace std;

FactorialData::FactorialData() {

	string line;
	ifstream file;
	file.open("factorials2");
	int index = 0;
	if( file.is_open() ) {
		while( !file.eof() ) {
			getline( file, line );
			double num = str2double( line );
			cout << "index = " << index << endl;
			factorials[index] = num;
			index++;
		}
	} else
		cout << "Fehler beim Öffnen der Datei factorials2." << endl;

	file.close();

	cout  << "factorials fertig." << endl;
}

double FactorialData::str2double(const string &str) {
	stringstream ss(str);
	double num = -1;
	if((ss >> num).fail())
		cout << "Error parsing " << str << " to double " << endl;
	return num;
}

Wenn ich das Programm ausführe erhalte ich folgenden Fehler (gdb):

index = 22950
index = 22951
index = 22952
index = 22953

Program received signal EXC_BAD_ACCESS, Could not access memory.
Reason: KERN_INVALID_ADDRESS at address: 0x00048000
0x00008cd8 in FactorialData::FactorialData (this=0x1b2b4) at FactorialData.cpp:20
20 factorials[index] = num;

Kann es sein, dass mein double Array zu groß gewählt ist?

Janjan

Ja, ist zu groß. Das muss schließlich in den Stack passen! Wenn ich mich recht erinner ist die maximale Größe für ein Array 64 kByte. Solch große Datenmengen solltest du auf dem Heap reservieren.

Hab jetzt den Code ein wenig geändert:

class FactorialData {

	public:
	static const int factorialStepSize = 20000;
	static const int size = 100000;
	double* factorials;
	FactorialData();
	double str2double(const std::string &str);

};

und die cpp-Datei

FactorialData::FactorialData() {

	factorials = new double[size];

	string line;
	ifstream file;
	file.open("factorials2");
	int index = 0;
//...etc...

Nun funktionierts.

Google hat mir irgendwas von Stack und Heap erzählt. Ist das der Grund? Kann mir das jemand erklären?

Janjan

HändyÄndy schrieb:

Google hat mir irgendwas von Stack und Heap erzählt. Ist das der Grund? Kann mir das jemand erklären?

Jedes Programm bekommt ein paar MB Stack zugewiesen bei Programmstart. In diesem Stack werden alle lokalen Variablen gespeichert. Der Client kümmert sich um den Stack, die Größe ist festgesetzt. Ist der Stack voll, crasht das Programm (Stack Overflow). Der "Heap" ist der restliche Arbeitsspeicher - um den kümmert das Betriebssystem sich. Dort musst du also Speicher erst beantragen.

Fellhuhn

Und auch wieder freigeben am Ende. Macht keinen Unterschied wenn das Programm sich eh beendet, sollte man sich aber auf jeden Fall angewöhnen. In deinem Fall mit delete[] factorials;

Fedaykin

Warum hast du es nicht mal mit was kleineren Ausgetestet? Wenns dann geht ist es klar die größe. Aber rein rechnerisch merkt man auch, das es das sein kann.

Du reservierst ein double array mit 100000 plätzen.
(100.000 * 8 Byte)/1024 = 781,25 MB
sollte aber eigentlich noch machbar sein. Probier mal mit kleineren Datenmengen aus und erhöhe immer etwas. Du hast ja schon nen konkreten wert ab wann das auftritt. Reservier also erstmal nur für 10.000 Elemente speicher und schau ob es damit klappt.

Habe mal gelesen, dass die Stackgröße vom Compiler bestimmt wird. Darf man dem Glauben schenken?

Janjan

fufufu schrieb:

Habe mal gelesen, dass die Stackgröße vom Compiler bestimmt wird. Darf man dem Glauben schenken?

Ja. Die kann man mit Compiler-Optionen verändern. Aber 800mb Stack machen keinen Sinn..

Fellhuhn

... oder benutz gleich std::vector. (und dort reserve() benutzen um unnötiges Kopieren zu verhindern, so die Größe ca. bekannt ist)

Fedaykin schrieb:

Warum hast du es nicht mal mit was kleineren Ausgetestet? Wenns dann geht ist es klar die größe. Aber rein rechnerisch merkt man auch, das es das sein kann.

Du reservierst ein double array mit 100000 plätzen.
(100.000 * 8 Byte)/1024 = 781,25 MB
sollte aber eigentlich noch machbar sein. Probier mal mit kleineren Datenmengen aus und erhöhe immer etwas. Du hast ja schon nen konkreten wert ab wann das auftritt. Reservier also erstmal nur für 10.000 Elemente speicher und schau ob es damit klappt.

Tausch mal das M gegen ein K...

wxSkip

Janjan schrieb:

fufufu schrieb:

Habe mal gelesen, dass die Stackgröße vom Compiler bestimmt wird. Darf man dem Glauben schenken?

Ja. Die kann man mit Compiler-Optionen verändern. Aber 800mb Stack machen keinen Sinn..

Bei rekursiven Sortierverfahren z.B. muss man für große Arrays tatsächlich den Stack vergrößern (zumindest beim GCC). Beim GCC geht das so:

-Wl,--stack=Deine_Stack_Größe_in_Bytes