#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?

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?

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.

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?

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

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...

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