Ein einfacher Weg zu/von VARIANT Typen in C++ zu konvertieren

Question

es irgendwelche leicht zu bedien, High-Level-Klassen oder Bibliotheken mit denen Sie mit VARIANT s in Visual C++ zu interagieren?

Genauer gesagt, würde Ich mag zwischen POD-Typen konvertieren (z double, long), Streicher (z CString) und Behälter (z std::vector) und VARIANT s. Zum Beispiel:

long val = 42; 
VARIANT var; 
if (ToVariant(val, var)) ...  // tries to convert long -> VARIANT 
comObjPtr->someFunc(var); 

std::vector<double> vec; 
VARIANT var = comObjPtr->otherFunc(); 
if (FromVariant(var, vec)) ... // tries VARIANT -> std::vector<double> 

I (? Naiv) angenommen, dass Menschen mit COM tun dies die ganze Zeit arbeiten, so würde es höchstwahrscheinlich eine einzige bequeme Bibliothek sein, die alle Arten von Konvertierungen behandelt. Aber alles, was ich in der Lage gewesen zu finden, ist eine bunte Auswahl von Wrapper-Klassen, die jeweils konvertiert ein paar Typen:

• _variant_t oder CComVariant für POD-Typen
• _bstr_t, CComBSTR oder BSTR für Streicher
• CComSafeArray oder SAFEARRAY für Arrays

gibt es eine einfache Art und Weise - kurz zu Visual Basic Schalt - diesen Alptraum umständlich Speicher zu vermeiden verwalten ment und bitweise VT_ARRAY | VT_I4 code?

Verwandte Fragen:

• CComVariant vs. _variant_t, CComBSTR vs. _bstr_t
• Convert VARIANT to...?
• How to best convert VARIANT_BOOL to C++ bool?

Answer 1

Nun wird der größte Teil der harten Arbeit für Sie bereits mit den verschiedenen Wrapper-Klassen erfolgen. Ich bevorzuge _variant_t und _bstr_t, da sie eher für die Konvertierung von/nach POD-Typen und Zeichenketten geeignet sind. Für einfache Arrays benötigen Sie nur die Template-Konvertierungsfunktion. Etwas wie folgt aus:

// parameter validation and error checking omitted for clarity 
template<typename T> 
void FromVariant(VARIANT Var, std::vector<T>& Vec) 
{ 
    CComSafeArray<T> SafeArray; 
    SafeArray.Attach(Var.parray); 
    ULONG Count = SafeArray.GetCount(); 
    Vec.resize(Count); 
    for(ULONG Index = 0; Index < Count; Index++) 
    { 
     Vec[Index] = SafeArray[Index]; 
    } 
} 
.... 
std::vector<double> Vec; 
VARIANT Var = ...; 
FromVariant(Var, Vec); 
... 

Natürlich Dinge haarig (in Bezug auf Speicher-/Lebensdauer-Management), wenn das Array nicht-POD-Typen enthält, aber es ist immer noch machbar.