object in c++

Du hast doch blos ein "value" und da steckt der Wert *und* der Typ drin... was soll denn in Deinem Beispiel das "datatype" sein? Wo kommt das her?

Nein ich habe 2 Datentypen.
"Datatype" kommt von der Oberfläche. Also noch weiter ausgeholt. Ich lese eine Liste von Variablen von einem anderen System ein und stelle diese Werte in einer Liste dar. Nun kann ich einen Variable aus der Liste auswählen und erhalte von ihr, den aktuellen Wert und ihren Datentyp.

z.b.

Name: Info
Typ: Double
Wert: 5.0

So nun möchte ich den Wert ändern. Schreibe in die Textbox den neuen wert von 10. So da dies nun immer ein anderer Datentyp sein kann, ist das Textfeld ein String wert.

Also nun steht eine 10 im Textfeld. Diese 10 soll nun der besagten Funktion übergeben werden. Und da die Funktion aber auch von einer anderen Stelle aufgerufen werden kann, muss diese Funktion nicht nur String entgegen nehmen sondern auch andere Werte. Deshal in c# object und in c++ void* oder VARIANT.

Nun muss ich also in der Funktion den Wert aus dem Parameter heraus bekommen.

Also z.B. der besagte String. Meine erstes switch case. Nun muss ich ja aber den wert, in unserem Beispiel, noch in double wandeln.

Nun klar?

Jochen Kalmbach

Ich verstehe nicht, warum Du Deinen "datatype" nicht in "value.vt" packst...

Oder wenn Du willst auch einen eigene Struktur dafür machst:

tyepdef struct tMyVariant {
  DataTypes datatyp;
  union {
    int integer;
    bool boolean;
    std::string string; 
    // usw.
  }
};

Ich pack doch meinen Datentyp in value.vt
Und da steht nun "String" drin.

Und nun weiß ich dass in meinem VARIANT ein String drin ist. Aber den String muss ich doch nun noch in einen double wandeln.

Jochen Kalmbach

Ja ok.. dann hast Du halt zwei Ebenen... hab es zwar immer noch nicht ganz verstanden, warum Du das brauchst... aber egal...

Du hattest doch geschrieben dass Du als "Input" *immer* einen String bekommst... also gibt es doch nur eine Ebene, da die zweite ja immer "String" ist, oder?

Nochmals ganz einfach:

Ich übergebe einer Funktion einen Wert der differiert.
Und in der Funktion wird nun entschieden in welchen Datentyp gewandelt werden muss.

So können also verschiedenste konstellation entstehen.

String to double
String to int
int to double
usw.

Du hattest doch geschrieben dass Du als "Input" *immer* einen String bekommst...

Wo habe ich das geschrieben das musst du mir zeigen!

Jochen Kalmbach

War nur meine interpretation.. .ist auch egal.. Du weisst ja wie Du es machen kannst ;=)

Du weisst ja wie Du es machen kannst ;=)

Wie jetzt wo habe ich das nun wiederum gesagt. Ich habe doch noch keine Lösung!

ihoernchen

Ich hab es auch nicht 100%ig verstanden. Poste am besten die C# Funktion.
Falls du willst beschreibe mal die Aufgabenstellung abstrakt (also was du lösen willst). Mir erscheint das ganze gecaste etwas seltsam. Sowas ist nur selten notwendig.

Die c# Funktion kann ich nicht posten. Da ich die funktion selber nicht habe. Habe nur die Funktionsbeschreibung.

Also noch ein Versuch:

1. Dialog: Liste von Variablen eines fremden Systems
2. Dialog: Bestimmte Variable wird ausgewählt.
3. Variable hat Name, Wert und Datentyp
4. Dialog: Der Wert soll nun geändert werden.
5. Dialog: Eingabefeld ist String.
6. Wert wird eingegeben. Button Wert schreiben
7. Funktion wird aufgerufen. Dieser Funktion wird der String übergeben und die Informationen der Variablen
8. Funktion entscheidet nun anhand des Variablentyps in der Variableninformation in welchen Wert der String umgewandlet werden muss.
9. Funktion wird aber auch von anderer Stelle aufgerufen und dort z.B. ein Int übergeben und kein String.
10. So nun muss ich erstmal entscheiden. Was kommt rein. String, int double.
11. Dann muss ich entscheiden in was ich den Wert wandeln muss den ich erhalten habe. Und das anhand der Variableninformation der Variablen an der ich den Wert senden soll.

So wenn nun was nicht verstanden Schritt nennen der unklar ist.

ihoernchen

Du wirst es dann mehr oder weniger so machen müssen wie schon ein paar mal vorgeschlagen (mit einer Container Klasse).
Ich denke in C# sieht es vielleicht anders aus, vom Prinzip passiert aber wohl das selbe was du in C++ machen musst.

Du kannst dir evtl. noch ein switch sparen. Vorschlag:

Variant ToInt(Variant v)
{
  switch(v.datatype)
  {
    case STRING:
      return Variant(INT,StringToInt(v.StringValue));
   ...
  }
}
Variant ToDouble(Variant v);
....

// array mit Funktionen zum Konvertieren (ToInt,ToDouble,...)
Variant (*ConvertFunction)(Variant v);
ConvertFunction convertFunctions[2];

enum Datatype
{
  INT = 0,
  DOUBLE = 1,
  ...
};

// konvertiere v zum Datentyp t
Variant Convert(Variant v,Datatype t)
{
   return (*convertFunctions[t])(v);
}

wie schon ein paar mal vorgeschlagen

Bis jetzt wurde das noch gar nicht vorgeschlagen: Aber nun habe ich wie gesagt ewig viele switch cases. Naja.

Jochen Kalmbach

gaugler schrieb:

Die c# Funktion kann ich nicht posten. Da ich die funktion selber nicht habe. Habe nur die Funktionsbeschreibung.

Wie meinst Du das? Mit Reflector kannst Du doch alles anschauen...

Wie meinst Du das?

Na so wie ich es sage.

Mit Reflector kannst Du doch alles anschauen...

Schön. Wußte ich nicht, da ich nicht mit c# programmiere.

Aber ich teste es jetzt mal.

So habe nun mal Reflector benutzt. Funktioniert ja super.
Tja was soll ich sagen die Funktion ist ewig groß mit verschachtelten switch case und if else if Anweisungen.

Also dann habe ich ja meine Lösung auch wenn ich nicht begeistert bin

ihoernchen

Viel anders wird das nicht gehen.
Wie gesagt du kannst dir wohl eine Ebene switches sparen, wenn du arrays von Funktionszeigern benutzt (alternativ z.B. std::map). Das ist dann wohl auch übersichtlicher.

ihoernchen schrieb:

Wie gesagt du kannst dir wohl eine Ebene switches sparen, wenn du arrays von Funktionszeigern benutzt (alternativ z.B. std::map)

Wie "Wie gesagt", das hast du doch nun zum ersten mal erwähnt.
Ich weiß noch nicht genau wie du das meinst. Wie soll das funktionieren? Kannst du mir einen Ansatz geben.