Probleme beim Bereitstellen von Speicher für sehr viele Werte

bitti1

Hallo!
Ich will bis zu 65.000 - ggf. auch mehr - Werte von Typ double speichern.
Der Zugriff soll dabei sehr schnell sein.
Das Problem bei meiner Lösung (siehe Code) ist, dass der Speicher zwar erstmal bereitgestellt wird aber wieder "verloren" geht.
Dh. sobald das Programm aus der Methode rausgeht ist der Speicher wieder "futsch".

template<typename T>
void SPEK::resizeVector(vector< vector<T> > &vec, size_t zeilen, size_t spalten)
{	
    //erste Dimension (Zeilen erzeugen)
    refValues.resize(zeilen);

    //Spalten hinzufügen (2. Dimension)
    for (size_t r = 0; r < maxValues; r++) 
    {
        refValues[r].resize(spalten); 

	// Zellen mit 0 füllen		
	for(size_t c = 0; c < spalten; c++)
	   refValues[r][c] = 0;			
     }
}

Habe es auch schon mit einem 2D-Array versucht, hat aber keine Besserung gebracht.

Simon2

bitti1 schrieb:

...sobald das Programm aus der Methode rausgeht ist der Speicher wieder "futsch"....

Also das klingt mir nicht nach einem Speicherproblem (zumal 65K doubles auch nicht wirklich viel sind auf heutigen Kisten), sondern eher nach einem "Kopierproblem".

Wer oder was sind denn "refValues" und "maxValues" ?
Diese Version funktioniert jedenfalls bei mir:

template<typename T>
void resizeVector(vector< vector<T> > &vec, size_t zeilen, size_t spalten) {
    vec.resize(zeilen);

    for (size_t r = 0; r < zeilen; r++)
    {
        vec[r].resize(spalten);

       for(size_t c = 0; c < spalten; c++)
          vec[r][c] = 0;
    }

}

int main() {
   vector<vector<double> > vv;
   cout << vv.size() << "\n";
   for(size_t i=0; i<vv.size(); ++i) cout << i << ". " << vv[i].size() << "\n";

   resizeVector(vv, 2, 3);

   cout << vv.size() << "\n";
   for(size_t i=0; i<vv.size(); ++i) cout << i << ". " << vv[i].size() << "\n";
   return 0
}

Weißt Du, dass Du bei resize bereits die Werte initialisieren kannst (jedenfalls mit immer demselben Wert) ?
Ich hätte es eher so gemacht:

template<typename T>
void resizeVector2(vector< vector<T> > &vec, size_t zeilen, size_t spalten)
{
   vector<T> tmp(spalten, 0.);
   vec.resize(zeilen, tmp);
}

(bzw. mir diesen 2Zeiler ganz gespart, wenn er sonst nichts weiter macht )

Gruß,

Simon2.

bitti1

Vielen, vielen Dank!
Das hat wunderbar funktioniert mit den 2 Zeilen Code

Ich bin mir nicht ganz sicher woher die Probleme kamen.
Kann es sein, dass der Compiler Probleme mit dem Attributnamen 'max_Values' ( -> max. Anzahl an Werten) hatte?
Habe hier mal so etwas gelesen, dass die Kombination Unterstrich '_' gefolgt von einem Großbuchstaben (hier: 'V') Probleme machen kann.

asc

bitti1 schrieb:

Habe hier mal so etwas gelesen, dass die Kombination Unterstrich '_' gefolgt von einem Großbuchstaben (hier: 'V') Probleme machen kann.

Es geht nur um Bezeichner die mit einem oder zwei Unterstrichen beginnen (Auch wenn ich persönlich Unterstriche nur in Makros verwende).

bitti1

Die Ursache, dass der Speicher immer "verloren" ging, liegt / lag an folgender Konstruktion:

//Stadart Konstruktor	
SPEK::SPEK()
{
	//Standartwert
	size_t values = 65000;

	SPEK::SPEK(values);	
}

SPEK::SPEK(size_t values)
{
	this->maxValues = values;

	resizeVector(refValues, maxValues, 2);
}

Nach Beendigung des Konstruktors SPEK(size_t values) und Rücksprung in den Parameterlosen Konstruktor gabs den bereitgestellten Speicher nicht mehr .

Du könntest die 65000 auch als Defaultwert in die Parameterliste eintragen und dir somit den zweiten Konstruktor sparen!

class SPEK {
   SPEK( size_t some = 65000 );
};

Simon2

bitti1 schrieb:

...

//Stadart Konstruktor	
SPEK::SPEK()
{
...	SPEK::SPEK(values);	
}

Der "Quersprung bei Konstruktoren" geht in C++ (noch) nicht. Vermutlich hast Du da ein neues (temporäres) Objekt angelegt, das hinterher wieder gelöscht wurde...

Gruß,

Simon2.

bitti1

Auf die Idee bin ich nicht gekommen, dass ich an der Stelle ein temporäres Objekt anlege. Aber es ergibt Sinn und erklärt das Verhalten des Programms.

Vielen Dank an Alle für die Tipps.