Un modo semplice per convertire da/per i tipi variante in C++

Question

ci sono eventuali facile da usare, classi di alto livello o librerie che permettono di interagire con VARIANT s in Visual C++?

Più in particolare, mi piacerebbe per la conversione tra i tipi di POD (ad esempio double, long), stringhe (ad esempio CString), e contenitori (ad esempio std::vector) e VARIANT s. Per esempio:

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 (? Ingenuamente) assume che le persone che lavorano con COM fare questo tutto il tempo, quindi non ci sarebbe molto probabilmente una singola libreria comodache gestisce tutti i tipi di conversioni. Ma tutto quello che ho potuto trovare è un vasto assortimento di classi wrapper che ogni convertire alcuni tipi:

• _variant_t o CComVariant per i tipi di POD
• _bstr_t, CComBSTR, o BSTR per archi
• CComSafeArray o SAFEARRAY per gli array

esiste un modo semplice - a corto di passare a Visual Basic - per evitare questo incubo della memoria scomoda manage codice bit e bit VT_ARRAY | VT_I4?

domande correlate:

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

Answer 1

Ebbene, la maggior parte del lavoro è già fatto per voi con le varie classi wrapper. Preferisco _variant_t e _bstr_t in quanto sono più adatti per la conversione da/verso tipi di POD e stringhe. Per gli array semplici, tutto ciò di cui hai veramente bisogno è la funzione di conversione dei template. Qualcosa di simile a quanto segue:

// 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); 
... 

di cose naturalmente ottenere pelosa (per quanto riguarda la memoria di gestione/vita) se la matrice contiene i tipi non-POD, ma è ancora fattibile.