gefundenen Wert in Struktur ablegen (nur wie?)

[Thomas (Gast)]

Hallo Gemeinde.

Hintergrund: Ich lese eine Datei mit Werten ein. Die Datei sieht z.B. so 
aus:

WERT1: 3
WERT2: 5
WERT3: 10
WERT4: 3.1415

Diese Werte aus eben dieser Datei sollen nun an die entsprechende Stelle 
innerhalb der aktuellen Struktur abgelegt werden:

struct meineZahlen
{
   UINT32 zahl1;
   UINT32 zahl2;
   UINT32 zahl3;
   float  zahl4;
}

Soll bedeuten: Wenn ich die Datei nach WERT4 durchsuche, soll mir der 
Wert 3.1415 an die Stelle .zahl4 innerhalb meiner aktuell gültigen 
Strukur, dessen Adresse ich an eine Unterfunktion übergeben habe, 
abgelegt werden.

Ein Funktionsaufruf sieht z.B. so aus:
main(void)
{
   meineZahlen *aktZahlen;
   search("WERT4", &aktZahlen);

   meineZahlen *neueZahlen;
   search("WERT2", &neueZahlen);
}

Ziel:
aktZahlen.zahl4 = 3.1415;
neueZahlen.zahl2 = 5;

Wie muss die Fkt search() aussehen, damit mir dies gelingt?

Die Zuordnung soll hierbei allerdings nicht über eine riesige Switch- 
oder if-Verschachtelung a la

Struktur.zahl1 = Wert;
Struktur.zahl2 = Wert;
...

erfolgen, da die Struktur ziemlich riesig wird.

Kann ich die Strukturelemente irgendwie über eine Lookup-Table 
ansprechen, in der die Information über das "mapping" hinterlegt sind?
Darin würde stehen, dass z.B. immer

WERT2 --> .zahl2
WERT4 --> .zahl4

innerhalb der aktuellen Struktur, abgelegt werden soll.

Ich brauche dringend Hilfe hierbei.

Vielen Dank erst einmal.
Thomas

[Klaus W. (mfgkw)]

1. Hausaufgabe? Oder wozu das Ganze?

2. main() funktioniert icht; die struct existieren gar nicht.

3. Soll immer dieselbe Datei durchsucht werden?
Dann ist es doch schlauer, einmal am Anfang alle Werte zu lesen und bei 
Bedarf nur noch aus dem Speicher zu holen.
Wenn nicht: woher soll die Funktion wissen, aus welcher Datei sie lesen 
soll?

[Klaus W. (mfgkw)]

Thomas schrieb:
> Die Zuordnung soll hierbei allerdings nicht über eine riesige Switch-
> oder if-Verschachtelung a la
>
> Struktur.zahl1 = Wert;
> Struktur.zahl2 = Wert;
> ...
>
> erfolgen, da die Struktur ziemlich riesig wird.
>
> Kann ich die Strukturelemente irgendwie über eine Lookup-Table
> ansprechen, in der die Information über das "mapping" hinterlegt sind?
> Darin würde stehen, dass z.B. immer
>
> WERT2 --> .zahl2
> WERT4 --> .zahl4
>
> innerhalb der aktuellen Struktur, abgelegt werden soll.

Machen kann man das schon, aber ich kann mir nicht vorstellen, daß es in 
diesem Fall Sinn macht.
Neben der Lage, wo etwas abgelegt werden soll, fehlt ja auch noch die 
Info, welcher Typ es ist.

Kannst du etwas C?

[Karl H. (kbuchegg)]

Thomas schrieb:

> Ein Funktionsaufruf sieht z.B. so aus:
> main(void)
> {
>    meineZahlen *aktZahlen;

Ähm.
Du hast hier keine Struktur. Du hast nur einen Pointer auf eine Struktur 
vereinbart. Aber ein Pointer ist ja nicht die Daten selber.

Du brauchst schon ein Strukturobjekt selber, damit du in ihm Werte 
ablegen kannst.

    meineZahlen aktZahlen;

>    search("WERT4", &aktZahlen);

OK. search kriegt also einen Pointer auf das Objekt. Soweit so gut


> aktZahlen.zahl4 = 3.1415;
> neueZahlen.zahl2 = 5;

Diese SChreibweise könntest du benutzen, wenn neueZahlen ein 
STrukturobjekt wäre.
Aber in der Funktion hast du ja kein Objekt. Du hast einen Pointer 
darauf.

void search( const char* Label, meineZahlen* neueZahlen )
{
  ...
}

Also musst du den Pointer dereferenzieren, damit du auf das Objekt 
selber kommst und kannst dann auf den Member zugreifen

    (*neueZahlen).zahl2 = 5;

die Klammern sind notwendig, weil die Operatoren-Reihenfolge sonst 
falsch wäre.
Da aber diese Operation so häufig vorkommt und die Sache mit den 
Klammern Tippaufwand bedeutet, hat man dafür eine andere Schreibweise 
eingeführt, die genau das gleiche macht

    neueZahlen->zahl2 = 5;


Komisch das dein C-Buch dazu nichts zusagen hat. Normalerweise ist das 
ziemlich ausführlich und mit vielen Beispielen und Übungen beschrieben 
und zieht sich über entsprechend viele Seiten hin, eben weil es wichtige 
Grundlagen sind.

[Thomas (Gast)]

@Klaus:

Genau, ich habe bereits eine LookUp-Tabelle definiert, die auch den 
Datentype umfasst, da der Wert später noch (ausgehend von std::string) 
konvertiert werden muss.

// LookUp-Table fürs Mapping
// (z.B. der gefunden Wert WERT3 soll immer an .zahl3 
// innerhalb der aktuellen Struktur geschrieben werden)
struct sKeyDesc keyDescriptions[] = 
{
  //name,            -->       type,            ptr on struct element?
  { "WERT1",              TYPE_INT8},        // meineZahlen.zahl1
  { "WERT2",              TYPE_INT16},       // meineZahlen.zahl2
  { "WERT3",              TYPE_INT32},       // meineZahlen.zahl3
  { "WERT4",              TYPE_FLOAT}        // meineZahlen.zahl4
};

Als 3. Argument müsste nun eine Angabe folgen, die sich auf das Ziel/das 
Strukturelement bezieht. Nur wie sieht diese Angabe aus? (siehe oben)

Danke.

[Karl H. (kbuchegg)]

Du brauchst das offsetof Makro, um den Offset eines Members in Bezug auf 
den Strukturanfang festzustellen. Der kommt dann in deine Lookup 
Tabelle.

[Karl H. (kbuchegg)]

struct sKeyDesc keyDescriptions[] = 
{
  //name,            -->       type,            ptr on struct element?
  { "WERT1",   TYPE_INT8,    offsetof( struct meineZahlen, zahl1 )},        // meineZahlen.zahl1
  { "WERT2",   TYPE_INT16,   offsetof( struct meineZahlen, zahl2 )},       // meineZahlen.zahl2
  { "WERT3",   TYPE_INT32,   offsetof( struct meineZahlen, zahl3 )},       // meineZahlen.zahl3
  { "WERT4",   TYPE_FLOAT,   offsetof( struct meineZahlen, zahl4 )}        // meineZahlen.zahl4
};

und dann in der Funktion

....

bool search( const std::string& label, struct meineZahlen* pZahlen )
{
  ...

  for( i = 0; i < sizeof(keyDescriptions)/sizeof(*keyDescriptions); ++i ) {
    if( Label == keyDescriptions[i].name ) {
      if( keyDescriptions[i].type == TYPE_INT8 ) {
        ....
        uint8_t* pTarget = (uint8_t)( (unsigned char*)pZahlen + keyDescriptions[i].offset );
        *pTarget = gelesener_Wert;
      }

      else if( keyDescriptions[i].type == TYPE_INT16 ) {
        ...
        uint16_t* pTarget = (uint16_t)( (unsigned char*)pZahlen + keyDescriptions[i].offset );
      }
    }
  }
}

Schön ist das nicht gerade. Da müsste es in C++ eine bessere Lösung 
geben.

[Thomas (Gast)]

Danke. Vielleicht hat ja tatsächlich noch jemand eine bessere Lösung -> 
da wirklich unschön und ich in C++ programmiere.

Ich habe letzte Woche bereits mit dem MACRO offsetof gearbeitet.
Mein Problem war dort, dass die angegeben Beispiel-Struktur auch 
geschachtelt sein kann, also Elemente wiederum Strukturen sein können.

Dann ist die Lösung mit dem MACRO kaum handelbar.

Danke.

[Klaus W. (mfgkw)]

Thomas schrieb:
> ich in C++ programmiere.

Dann eine Map nehmen, die den Namen ("WERT1") auf den Rest (Typ, Wert) 
mappt.

[Thomas (Gast)]

@ Klaus:

Kannst du mir bitte deinen Lösungsansatz näher beschreiben?
Vielen Dank.

[Klaus W. (mfgkw)]

#include <iostream>
#include <map>
#include <utility>


class Wert
{
public:
  enum eWert
    {
      eWertInt,
      eWertFloat,
      eWertInvalid,
    };

  Wert()
    : m_typ(eWertInvalid)
  {
  }

  Wert( long l )
    : m_typ(eWertInt)
  {
    m_wert.l = l;
  }

  Wert( int l )
    : m_typ(eWertInt)
  {
    m_wert.l = l;
  }

  Wert( double d )
    : m_typ(eWertFloat)
  {
    m_wert.d = d;
  }

  Wert( const Wert &w )
    : m_wert( w.m_wert ),
      m_typ( w.m_typ )
  {
  }

  // virtual nur nötig, wenn davon etwas abgeleitet wird, dann auch virtual ~Wert()!
  virtual void toStream( std::ostream &os ) const
  {
    switch( m_typ )
    {
      case eWertInt:
        os << m_wert.l;
        break;

      case eWertFloat:
        os << m_wert.d;
        break;

      default :
        os << "<häh?>";
        break;
    }
  }

private:

  union
  {
    long    l;
    double  d;
  } m_wert;

  eWert  m_typ;

};

std::ostream &operator<<( std::ostream &os, const Wert &w )
{
  w.toStream( os );
  return os;
}

int main( int nargs, char **args )
{
  std::map< const char *, Wert>  werte;

  // Einfügen so:
  werte["WERT1"] =  3;
  werte["WERT2"] =  5;
  // oder so:
  werte.insert( std::pair<const char*,Wert>( "WERT3", Wert( 10 ) ) );
  werte.insert( std::pair<const char*,Wert>( "WERT4", Wert( 3.141592365 ) ) );

  // Testausgabe:
  std::cout << werte["WERT1"] << std::endl;
  std::cout << werte["WERT2"] << std::endl;
  std::cout << werte["WERT3"] << std::endl;
  std::cout << werte["WERT4"] << std::endl;
}