Eine Funktion mit mehreren Variablentypen aufrufen...



  • Hallo!

    Wie kann ich eine Funktion schreiben in die ich verschiedene Dateitypen übergebe?

    Ich have es mit VARIANT probiert, aber ich kann es nicht initialisieren...

    Wie kann ich eine VARIANT-Variable mit einem String oder Integer füllen?

    THX für eure Hilfe.



  • Ich weiß nicht genau wie du das meinst.
    Ich gehe mal davon aus, dass du eine Funktion hast die 1nen Parameter übernimmt und der soll entweder von int, long, double, char ... sein.

    Überschreibe doch deine Funktion für jeden Variablentyp.



  • Na super, dan habe ich 20 Funktionen, die nahezu gleich aussehen, das muß doch auch mit VARIANT gehen???



  • probiers mal mit templates



  • hmm finde einen datentyp variant nur bei visual basic..

    was ist variant?



  • ich kenne auch keinen 'variant'-typ bei c++
    nimm doch einfach 'void*'

    cu
    Dommel



  • Ok, ich sag's jetzt mal was ich machen will.
    Ich will eine Funktion schreiben, die Daten in die Registry schreibt. Weil die Daten aber alles Mögliche sind, will ich das mit einem Variant machen.

    Ach, übrigens, einen VARIANT gibt es sehr wohl in C++!
    Ich weis nur nicht wie ich ihn z.B. mit einem String füllen kann!

    void* kann ich nicht benutzen, weil ich wissen muß was das für ein Typ das ist!



  • hi,

    also ich hab keinen VARIANT-Typ für C++ in der MSDN gefunden. aber vielleciht gibt es den ja wirklich.

    wenn nicht, dann wirst du wohl kaum um mehrere funktionen herumkommen



  • wieso schreibst du dir nich ne eigene struct zb.:

    struct var
    {
        unsigned char type;
        union
        {
            long  l_val;
            short s_val;
            char  c_val;
    
            struct{ char* str; unsigned short str_length; };
            // den string musst du dann natürlich immer allocieren
            // und freigeben
        };
    };
    

    vielleicht hilfts ja...

    [EDIT]

    hab ich in der MSDN gefunden:

    Use VARIANTARG to describe arguments passed within DISPPARAMS, and VARIANT to specify variant data that cannot be passed by reference. The VARIANT type cannot have the VT_BYREF bit set. VARIANTs can be passed by value, even if VARIANTARGs cannot.

    typedef struct FARSTRUCT tagVARIANT VARIANT;
    typedef struct FARSTRUCT tagVARIANT VARIANTARG;
    
    typedef struct tagVARIANT  {
        VARTYPE vt;
        unsigned short wReserved1;
        unsigned short wReserved2;
        unsigned short wReserved3;
        union {
            unsigned char        bVal;                        // VT_UI1.
            short                    iVal;                        // VT_I2    .
            long                    lVal;                        // VT_I4    .
            float                    fltVal;                    // VT_R4    .
            double                dblVal;                    // VT_R8    .
            VARIANT_BOOL        boolVal;                        // VT_BOOL.
            SCODE                    scode;                    // VT_ERROR.
            CY                        cyVal;                    // VT_CY    .
            DATE                    date;                        // VT_DATE.
            BSTR                    bstrVal;                    // VT_BSTR.
            IUnknown                FAR* punkVal;            // VT_UNKNOWN.
            IDispatch             FAR* pdispVal;            // VT_DISPATCH.
            SAFEARRAY            FAR* parray;            // VT_ARRAY|*.
            unsigned char        FAR* pbVal;                // VT_BYREF|VT_UI1.
            short                    FAR* piVal;                // VT_BYREF|VT_I2.
            long                    FAR* plVal;                // VT_BYREF|VT_I4.
            float                    FAR* pfltVal;            // VT_BYREF|VT_R4.
            double                FAR* pdblVal;            // VT_BYREF|VT_R8.
            VARIANT_BOOL        FAR* pboolVal;                // VT_BYREF|VT_BOOL.
            SCODE                    FAR* pscode;            // VT_BYREF|VT_ERROR.
            CY                        FAR* pcyVal;            // VT_BYREF|VT_CY.
            DATE                    FAR* pdate;                // VT_BYREF|VT_DATE.
            BSTR                    FAR* pbstrVal;            // VT_BYREF|VT_BSTR.
            IUnknown FAR*        FAR* ppunkVal;            // VT_BYREF|VT_UNKNOWN.
            IDispatch FAR*        FAR* ppdispVal;        // VT_BYREF|VT_DISPATCH.
            SAFEARRAY FAR*        FAR* pparray;            // VT_ARRAY|*.
            VARIANT                FAR* pvarVal;            // VT_BYREF|VT_VARIANT.
            void                    FAR* byref;                // Generic ByRef.
        };
    };
    

    [/EDIT]

    mfg
    Plassy

    [ Dieser Beitrag wurde am 15.09.2002 um 13:58 Uhr von Plassy editiert. ]



  • Hallo zusammen,

    VARIANT ist ein Datentyp, dem sein Inhalt quasi wurscht ist. Er findet seine Anwendung u.A. bei der COM- Programmierung. Er besteht, um es mal so zu formulieren, aus quasi 2 Teilen. Der erste Teil beshreibt dier Art der der Daten, die in ihm drinstecken und der zweite Teil, sind die Daten selbst.

    So

    VARIANT var;
        var.vt = VT_I2;
        var.iVal = 3;
    

    weist du einem Variant z.B. einen integer zu.

    Bei Strings musst du allerdings beachten, dass du mit BStrings arbeiten musst.

    Gruß, Volle.



  • Hmm, jo, jetzt geht's...

    Oh Mann, ist das Doof!!!

    Wieso haben die keinen =-Operator zu jedem Datentyp Programmiert?

    Mannomann... Ich werde jetzt **wahrscheinlich eine eigene VARIANT-Classe programmieren, die =-Operatoren GANZ BESTIMMT hat!

    Hat jemand interresse dran?**



  • Und nochmal: Genau dazu sind Templates da!



  • Hi PanicMan,

    ich versteh dein Problem glaub nicht richtig...

    Du willst eine Funktion in der Form:

    void WriteReg(VARIANT regData)
    

    oder nicht.

    Die soll jetzt, je nachdem was für Daten kommen, die entsprechend in die Registry schreiben.

    Also musst du innerhalb der Funktion doch nur den Typ des Variants abfragen und entsprechend reagieren.

    Könnte so aussehen:

    switch(regData.vt)
        {
        case VT_I2:
            //schreibe Integer in Registry
        break;
        }
    

    Sooo schlimm ist das doch nicht, Da sooo dermaßen viele Typen für die registry nicht in Frage kommen.

    Im übrigen gibt es auch schon eine Klasse, die das ganze ein wenig kapselt. Nennt sich COleVariant. Aber ich benutze sie nicht so gerne.

    Grüße, Volle.



  • Ahja, habe das Problem schon gelöst, mache die übergabe mit VARIANT und die zuweisung mit CComVariant.

    THX für die Antworten.


Log in to reply