[C++] Array verliert Werte

[Maxim (maxim)]

Ich habe ein Array von void-Zeigern, genannt quantities. Ein Zeiger aus 
diesem Array zeigt auf ein int-Array. Dieses wird in der Methode void 
readConfigFile(string configFile) möchte ich mit der Mehtode int 
get(quantity::ofTypeInt q, size_t index); die Werte aus diesem int-Array 
auslesen.

Wenn ich das erste Element im int-Array mit

((int*)quantities[L])[0] = 7;

belege und es gleich in der nächsten Zeile auslese, funktioniert es ohne 
Probleme. Greife ich aber auf diesen Zeiger später außerhalb der Methode 
void readConfigFile(string configFile) zu (z.B. per get(L, 0)), bekomme 
ich keine 7 sondern irgend einen Müll. Woran kann das liegen?


inout.h

#ifndef INOUT_H
#define INOUT_H
#include "common.h"
#include <iterator>

using std::cout;
using std::cin;
using std::endl;
using std::flush;
using std::string;
using std::ifstream;
using std::ofstream;
using std::istringstream;
using std::istream_iterator;

namespace quantity {
  enum ofTypeInt {
    L,
    T,
    NLSteps,
    NTSteps,
    deltaStep,
    ofTypeIntCount = 5
  };
  
  enum ofTypeFp {
    dt,
    tEql,
    tAvg,
    ofTypeFpCount = 3
  };
  
  enum common {
    length = -1
  };
}

class InputOutput {
public:
  InputOutput();
  ~InputOutput();

  int get(quantity::ofTypeInt q);
  int get(quantity::ofTypeInt q, size_t index);
  fp_type get(quantity::ofTypeFp q);
  fp_type get(quantity::ofTypeFp q, size_t index);
  
   void readConfigFile(string configFile);
  
private:
  void *quantities[quantity::ofTypeIntCount + quantity::ofTypeFpCount];
};

#endif // INOUT_H

inout.cpp

#include "inout.h"
#include <boost/lexical_cast.hpp>

using std::vector;
using std::back_inserter;

using namespace quantity;

InputOutput::InputOutput() {
}

InputOutput::~InputOutput() {

}

void InputOutput::readConfigFile(string configFile) {
  string tmpStr;
  ifstream inputStream;
  
  if(configFile != "") {
    cout << "Loading configuration file " << configFile << endl;
    inputStream.open(configFile.c_str());
    do {
      getline(inputStream, tmpStr);
      cout << "line: " << tmpStr << endl;
      istringstream inputStringStream(tmpStr);
      vector<string> tokens;
      copy(istream_iterator<string>(inputStringStream), istream_iterator<string>(), back_inserter<vector<string>>(tokens));
      if(tokens.size() > 0) {
        if(tokens.at(0) == "L:") {
          quantities[NLSteps] = new int;
          *(int*)quantities[NLSteps] = tokens.size() - 1;
          
          quantities[L] = new int[*(int*)quantities[NLSteps]];
          
          ((int*)quantities[L])[0] = 7;
          cout << "test " <<  ((int*)quantities[L])[0] << endl;
      }
    } while(tmpStr != "");
    inputStream.close();
  }
  
}



int InputOutput::get(quantity::ofTypeInt q, size_t index) {
  switch(q) {
    case L: return ((int*)quantities[L])[index]; break;
    default: return 0;
  }
}

[Udo S. (urschmitt)]

Maxim S. schrieb:
> Greife ich aber auf diesen Zeiger später außerhalb der Methode
> void readConfigFile(string configFile) zu (z.B. per get(L, 0)), bekomme
> ich keine 7 sondern irgend einen Müll. Woran kann das liegen?

Sind denn die Variablen auf die die Zeiger zeigen ausserhalb der Methode 
überhaupt noch gültig? Oder waren das in der Methode lokal angelegte 
Variablen?

>Array verliert Werte
Köstlicher Titel :-) Dann musst du es abdichten.

[nicht "Gast" (Gast)]

Hallo,

zur Lösung kann ich nur ein beitragen.

Schmeiß dein void array weg. Das ist C und du willst so was nicht in C++ 
machen. (Da es unhöflich ist zu schreien, stell dir einfach alles in 
Großbuchstaben vor :)

Mit Void Zeigern arbeitet man in C++ nicht. in C++ will und kann man 
streng typisiert arbeiten. Das versuchst du zu umgehen.

Wenn du noch nicht weißt, was du in deinem Array speichern willst, 
benutz Templates oder in deinem Fall gleich einen std::vector

Grüße,

[Maxim (maxim)]

Udo Schmitt schrieb:
> Sind denn die Variablen auf die die Zeiger zeigen ausserhalb der Methode
> überhaupt noch gültig? Oder waren das in der Methode lokal angelegte
> Variablen?

void *quantities[N] ist im Header deklariert. Das int-Array wird in 
readConfigFile() mit new definiert, muss also nach meinem Wissen auch 
außerhalb der Methode verfügbar sein.

[Karl H. (kbuchegg)]

nicht "Gast" schrieb:

> Wenn du noch nicht weißt, was du in deinem Array speichern willst,
> benutz Templates oder in deinem Fall gleich einen std::vector

Zumal in diesem Beispiel wirklich nicht ersichtlich ist, wozu dieses 
void* Array tatsächlich gut sein soll, ausser das man sich durch 
ständige Casts selber ins Knie schiesst.

[Karl H. (kbuchegg)]

Maxim S. schrieb:
> Udo Schmitt schrieb:
>> Sind denn die Variablen auf die die Zeiger zeigen ausserhalb der Methode
>> überhaupt noch gültig? Oder waren das in der Methode lokal angelegte
>> Variablen?
>
> void *quantities[N] ist im Header deklariert. Das int-Array wird in
> readConfigFile() mit new definiert, muss also nach meinem Wissen auch
> außerhalb der Methode verfügbar sein.

Im Prinzip ja.
Solange du nur ein einziges derartiges InputOutput  Objekt hast.

Wir sind wieder dort, wo wir schon so oft waren: Mit den gegegenen 
INformationen kann man nicht entscheiden wo das konkret vorleigende 
Problem tatsächlich liegt. Man kann allerdings, abseits vom konkreten 
Problem schon sagen, dass der ganze Aufbau der Klasse zumindest 
zwielichtig ist. Das löst zwar das Problem nicht und eröffnet eine 
weitere Baustelle. Allerdings eine, die man auch fixen sollte - selbst 
wenn sie mit dem momentanen Problem erst mal wahrscheinlich nichts zu 
tun hat.

[Maxim (maxim)]

Ok, das war Quatsch. Ich bin auf Templates umgestiegen. Trotzdem würde 
mich die Fehlerquelle interessieren, da der Code so schon funktionieren 
sollte ...

[Karl H. (kbuchegg)]

Maxim S. schrieb:
> Ok, das war Quatsch. Ich bin auf Templates umgestiegen. Trotzdem würde
> mich die Fehlerquelle interessieren

bau Testcode ein.

Ausgaben in:
* Konstruktor
* Destruktor

In der Abfrage-Funktion testen auf 0-Pointer

Copy Constructor und Assignment Operator durch setzen in die 
private-Sektion der Klasse und nicht implementieren unbrauchbar machen. 
Das sollte man generell immer machen, wenn man sich selber an 
dynamischer Resource-Verwaltung versucht und noch nicht weiß wie man die 
beiden implementieren soll bzw. die nicht implementieren will. Ein 
Referenz-& in einer Funktions-Argument Liste ist schnell vergessen und 
dann wird eine Kopie der Pointer mit katastophalen Konsequenzen gemacht.

[Karl H. (kbuchegg)]

Ich seh nicht, inwiefern da jetzt Templates einen Vorteil gegenüber
einem simplen

...

  private:
    std::vector<int> L_Steps;
    std::vector<int> N_Steps;
    int              Delta_Step;

    double dt;
    double tEql;
    double tAvg;
};

bringt.

[Josef (Gast)]

Hier

          quantities[NLSteps] = new int;
          *(int*)quantities[NLSteps] = tokens.size() - 1;

          quantities[L] = new int[*(int*)quantities[NLSteps]];

wird doch ein Element zu wenig angelegt, oder?
(Also bei tokens.size()==1 gibt das new int[0]).

Der Code ist schrecklich. Ich wuerde auch empfehlen in umzuschreiben,
oder eine Menge Kommentare dazu zu machen.

Gruss