Parameterübergabe

gerritgoetzen

Hallo zusammen!

Ich bin grade dabei eine statische Bibliothek für eine Messkarte (diese kommt vom Hersteller mit entsprechendem Header / alles in C geschrieben) in eine neue statische Bibliothek einzubauen. Ziel ist die Vereinfachung aller Funktionen, automatische Fehlerverarbeitung etc. Nun habe ich eine Liste von Konstanten, besser gesagt Definitionen, wie z.B. hier:

#define AO_BUFFERED             0x1
#define AO_TRANSPARENT          0x2
#define AO_...                  ...

In einer Funktion, zum einstellen des Modus der Karte, soll dann einer dieser Werte übergeben werden. Da ich aber ja alles C++ und "objektorientiert" haben möchte, sollten diese Definitionen lieber Konstanten sein. Da es außerdem eine ganze Menge davon gibt und alles ja einfacher werden soll, dachte ich mir, ich verpacke diese Konstanten alle in Strukturen. Das Beispiel oben also so:

struct AO {
  struct Mode {
    static const unsigned int Buffered       = 0x1;
    static const unsigned int Transparent    = 0x2;
    ...
  };

  struct ... {
  };
};

Jetzt kann ich also die Funktion meiner Klasse etwa so schreiben:

int setMode(AO::Mode AOMode);

Ich dachte mir, auf diese Art und Weise können keine falschen Werte übergeben werden und beim Programmieren später muss ich keine Definitionslisten vor mir haben und weiß sofort wo ich die entsprechende Einstellung finde. Aufruf der Funktion also etwa so:

error = setMode(AO::Mode::Buffered);

Nun zu meinen Fragen:

Ist dieses Vorgehen überhaupt sinnvoll/gut/effektiv/etc
Meine Funktion (setMode) ist ja eigentlich nur eine Wrapperfunktion die mir später einiges an Verwaltungsaufwand abnimmt und dann die Originalfunktion des Herstellers aufruft. Dort muss ich dann diesen Parameter natürlich übergeben, allerdings als Integer. Ein automatische Cast (also einfach nur den Parameter weitergeben) oder static_cast<int> führt aber zum Fehler

error C2440: '<function-style-cast>': 'AO::Channel' kann nicht in 'int' konvertiert werden. Kein benutzerdefinierter Konvertierungsoperator verfügbar, der diese Konvertierung durchführen kann, oder der Operator kann nicht aufgerufen werden

Außerdem habe ich doch die Konstante selbst als "int" definiert. Was ist da mein Verständnissfehler.
3) Ist soetwas schonmal diskutiert worden? Die Suche nach "Parameter" und einigen Abwandlungen hat mich nicht weiter gebracht. Suche ich nach dem falschen Begriff?

Das war jetzt erstmal ganzschön viel. Ich hoffe Ihr könnt mich da Beraten. Meine Bücher lassen mich jedenfalls im Stich.

Gruß Gerrit

*D*Evil

enum (enumeration)

gerritgoetzen

Danke für die schnelle Antwort.

Ich habe mich da direkt mal mit beschäftigt. Mir sind nun zwei Probleme aufgefallen:

Kann ich die Enums auch verschachteln?
Der Compiler akzeptiert nur Ganzzahlen. Was mache ich mit den Konstanten die z.B. vom float- oder string-Typ sind?

Ist das eigentlich auch der "standardweg" den die Profis nutzen?

Danke nochmal.
Gerrit

gerritgoetzen schrieb:

Danke für die schnelle Antwort.
Ist das eigentlich auch der "standardweg" den die Profis nutzen?

Es gibt keinen Standardweg.

Die Idee mit diesen Strukturen ist nicht schlecht, in der Fehlermeldung wird aber AO::Channel bemänglet. Liegt vielleicht der Fehler daran, das versucht wird, eine ganze Struktur in ein int zu pressen?

gerritgoetzen

Hmm...
richtig!

Wenn ich in der Funktion den Parameter einfach als "int" lasse...
also so:

int setMode(int AOMode);

...dann kann ich ja z.B. "AO::Mode::Buffered" übergeben, denn das ist ja ein "int".
Der Witz an der Sache sollte aber sein, dass ich dann in der VC-IDE einfach mit Hilfe der Anweisungsvervollständigung und den Parameterinformationen weiß, was für ein Parameter erwartet wird und der mir auch die Member auflistet.

Vielleicht hat ja jemand eine Lösung für das Problem.

Ich glaube ich übersehe da einfach was. Wird das in .NET nicht auch so ähnlich gemacht (wie ich das vor hatte)?

Jetzt gehts aber erstmal nach hause. Ich werde mich da morgen weiter mit beschäfftigen. Wenn ich eine gute Lösung habe (oder jemand Anders), dann fasse ich den Lösungsweg hier kurz zusammen. Das Problem hatten sicher schon manche.

Schönen Feierabend.
Gerrit

*D*Evil

struct AO 
{
    enum Mode 
    {
        buffered = 0x1,
        transparent = 0x2,
    };
    enum ... 
    {
    };
};

oder wie willst du es haben?!