Una manera simple de convertir a/de tipos de variantes en C++

Question

¿Hay alguna fácil de usar, clases de alto nivel o bibliotecas que le permiten interactuar con VARIANT s en Visual C++?

Más específicamente, me gustaría para convertir entre tipos de POD (por ejemplo double, long), cadenas (por ejemplo CString), y los contenedores (por ejemplo std::vector) y VARIANT s. Por ejemplo:

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) supone que las personas que trabajan con COM hacen esto todo el tiempo, por lo que sería más probable es que sea una sola biblioteca convenienteque se encarga de todo tipo de conversiones. Pero todo lo que he podido encontrar es un variado surtido de clases contenedoras que convierten cada unos tipos:

• _variant_t o CComVariant para este tipo POD
• _bstr_t, CComBSTR o BSTR para cuerdas
• CComSafeArray o SAFEARRAY para matrices

¿hay alguna forma sencilla - corto de cambiar a Visual Basic - para evitar esta pesadilla de gestionar la memoria incómoda y código bit a bit VT_ARRAY | VT_I4?

preguntas relacionadas:

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

Answer 1

Bueno, la mayor parte del trabajo duro ya está hecho para usted con las diversas clases de envoltura. Prefiero _variant_t y _bstr_t ya que son más adecuados para la conversión a/desde tipos y cadenas de POD. Para arreglos simples, todo lo que realmente necesita es la función de conversión de plantilla. Algo así como lo siguiente:

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

por supuesto las cosas se ponen peludas (en lo que respecta a la gestión de memoria/vida) si la matriz contiene los tipos no-POD, pero todavía es factible.