常用数据与VARIANT之间的转换---从网上整理

//头文件
 1 #pragma once
 class VariantConvert
 {
 public:
     VariantConvert(void);
     ~VariantConvert(void);

 public:
     void short2Variant(short sData,VARIANT &va);
     //VARIANT short2Var(shortsData);
     void long2Variant(long lData,VARIANT& va);
     void float2Variant(float fData, VARIANT& va);
     void double2Variant(double dData,VARIANT &va);
     void unChar2Variant(unsigned char chData,VARIANT &va);
     void arrayDouble2Variant(double *pArray,int iDim1Num,int iDim2Num,VARIANT &vaArray);
     void arrayDouble2Variant(double *pArray,int iDimlength,VARIANT &vaArray);
     void arraylong2Variant(long *pArray,int iDim1Num,int iDim2Num,VARIANT& vaArray);
     void arraylong2Variant(long *pArray,int iDimlength,VARIANT &vaArray);
     //void arrayunChar2Variant(byte *pArray,int iDim1Num,int iDim2Num,VARIANT &vaArray );
     void arrayunChar2Variant(byte *pArray,int iDimlength,VARIANT &vaArray);
 public:
     //void Variant2Data(VARIANT vaData, void&Data);
     bool Variant2short(VARIANT vaData, short &sData);
     bool Variant2long(VARIANT vaData, long & lData);
     bool Variant2float(VARIANT vaData,float& fData);
     bool Variant2double(VARIANT vaData,double & dData);
     void Variant2Array(VARIANT vaArray,UINT &iDim,long&iDim1Num,long &iDim2Num,LPVOID *pData);
     void Variant2Array(VARIANT vaArray,UINT &nDim,long&lDimLenght,VOID** pData);
 };

实现文件

#include "StdAfx.h"
#include "VariantConvert.h"

VariantConvert::VariantConvert(void)
{
}

VariantConvert::~VariantConvert(void)
{
}
void VariantConvert::short2Variant(short sData,VARIANT& va)
{
	va.vt=VT_I2;
	va.iVal = sData;
}

void VariantConvert:: long2Variant(long lData,VARIANT& va)
{
	va.vt = VT_I4;
	va.lVal = lData;
}

void VariantConvert::float2Variant(float fData,VARIANT& va)
{
	va.vt = VT_R4;
	va.fltVal = fData;
}

void VariantConvert::double2Variant(double dData,VARIANT& va)
{
	va.vt = VT_R8;
	va.dblVal = dData;
}

void VariantConvert::unChar2Variant(unsigned char chData,VARIANT& va)
{
	va.vt = VT_UI1;
	va.bVal = chData;
}

void VariantConvert::arrayDouble2Variant(double *pArray,int iDim,int iDim1Num,int iDim2Num,VARIANT&vaArray)
{

	SAFEARRAY *psa;
	SAFEARRAYBOUND rgsabound[2];// 二维需要定义两个元素
	rgsabound[0].lLbound =0; // 一维的下界（下界就是下标的最小值）
	rgsabound[0].cElements=iDim1Num; // 一维的元素的个数
	rgsabound[1].lLbound =0; // 二维的下界
	rgsabound[1].cElements =iDim2Num; // 二维的元素的个数
	long lIndex[2]; // 定义索引
	psa = SafeArrayCreate(VT_R8,2, rgsabound); // 按照二维数组分配空间
	for ( long k = 0; k< iDim1Num; k++)
	{
		lIndex[0] =k;
			for (long num = 0; num < iDim2Num;num++)
			{
				lIndex[1] =num;
				SafeArrayPutElement (psa, lIndex,&pArray[k*iDim2Num+num]); //lIndex作为SAFEARRAY中的索引。
			}
	}

	vaArray.vt =VT_ARRAY|VT_R8; // 类型
	vaArray.parray =psa; // 赋值

}

// One dimension Convert
void VariantConvert::arrayDouble2Variant(double *pArray,int iDimlength,VARIANT &vaArray)
{
	SAFEARRAY *psa;
	SAFEARRAYBOUND rgsabound[1];
	rgsabound[0].lLbound=0;
	rgsabound[0].cElements=iDimlength;
	psa = SafeArrayCreate(VT_R8,1,rgsabound);
	long lIndex[1];
	for (int k=0; k < iDimlength; k++)
	{
		lIndex[0]=k;
		SafeArrayPutElement(psa,lIndex,&pArray[k]);
	}
	vaArray.vt = VT_ARRAY|VT_R8;
	vaArray.parray= psa;
}

void VariantConvert::arraylong2Variant(long *pArray,int iDim1Num,int iDim2Num,VARIANT& vaArray)
{
	SAFEARRAY *psa;
	SAFEARRAYBOUND rgsabound[2]; // 二维需要定义两个元素
	rgsabound[0].lLbound =0; // 一维的下界
	rgsabound[0].cElements=iDim1Num; // 一维的元素的个数
	rgsabound[1].lLbound =0; // 二维的下界
	rgsabound[1].cElements =iDim2Num; // 二维的元素的个数
	long lIndex[2]; // 定义索引
	psa = SafeArrayCreate(VT_I4, 2, rgsabound); // 按照二维数组分配空间
	for ( long k = 0; k < iDim1Num; k++){
		lIndex[0] =k;
			for (long num = 0; num < iDim2Num;num++ )
			{
				lIndex[1] =num;
				SafeArrayPutElement (psa, lIndex,&pArray[k*iDim2Num+num]); //lIndex作为SAFEARRAY中的索引。
			}
	}
	vaArray.vt = VT_ARRAY|VT_I4;
	vaArray.parray = psa;
}

void VariantConvert::arraylong2Variant(long *pArray,int iDimlength,VARIANT &vaArray)
{
	SAFEARRAY *psa;
	SAFEARRAYBOUND rgsabound[1];
	rgsabound[0].lLbound=0;
	rgsabound[0].cElements=iDimlength;
	psa = SafeArrayCreate(VT_I4,1,rgsabound);
	long lIndex[1];
	for (int k=0; k < iDimlength; k++)
	{
		lIndex[0]=k;
		SafeArrayPutElement(psa,lIndex,&pArray[k]);
	}
	vaArray.vt = VT_ARRAY|VT_I4;
	vaArray.parray= psa;
}
//
//
//
void VariantConvert::arrayunChar2Variant(byte *pArray,int iDim1Num,int iDim2Num,VARIANT& vaArray)
{
	SAFEARRAY *psa;
	SAFEARRAYBOUND rgsabound[2]; // 二维需要定义两个元素
	rgsabound[0].lLbound =0; // 一维的下界
	rgsabound[0].cElements=iDim1Num; // 一维的元素的个数
	rgsabound[1].lLbound =0; // 二维的下界
	rgsabound[1].cElements =iDim2Num; // 二维的元素的个数
	long lIndex[2]; // 定义索引
	psa = SafeArrayCreate(VT_UI1, 2, rgsabound); // 按照二维数组分配空间
	for ( long k = 0; k < iDim1Num; k++)
	{
		lIndex[0] =k;
		for (long num = 0; num < iDim2Num;num++)
		{
			lIndex[1] =num;
			SafeArrayPutElement (psa, lIndex,&pArray[k*iDim2Num+num]); //lIndex作为SAFEARRAY中的索引。
		}
	}
	vaArray.vt =VT_ARRAY|VT_UI1; //vaArray为安全数组类型，每个元素为unsigned char 类型
	vaArray.parray =psa;
}
//
//
//
void VariantConvert::arrayunChar2Variant(byte *pArray,int iDimlength,VARIANT &vaArray)
{
	SAFEARRAY *psa;
	SAFEARRAYBOUND rgsabound[1];
	rgsabound[0].lLbound=0;
	rgsabound[0].cElements=iDimlength;
	psa = SafeArrayCreate(VT_UI1,1,rgsabound);
	long lIndex[1];
	for (int k=0; k < iDimlength; k++)
	{
		lIndex[0]=k;
		SafeArrayPutElement(psa,lIndex,&pArray[k]);
	}
	vaArray.vt = VT_ARRAY|VT_UI1;
	vaArray.parray= psa;
}
////////////////////////////////////////////////////////////////////////////
//
//
//
// void VariantConvert::Variant2Data(VARIANT vaData, void& Data)
// {
// switch(vaData.vt)
// {
//   case VT_I2:
//   Data =vaData.iVal;
//  break;
//   case VT_I4:
//   Data =vaData.lVal;
//  break;
//   case VT_R4:
//   Data =vaData.fltVal;
//  break;
//   case VT_R8:
//   Data =vaData.dblVal;
//  break;
//   case VT_UI1:
//   Data =vaData.bVal;
//  break;
//
// }
//}
//
//
//
bool VariantConvert::Variant2short(VARIANT vaData, short& sData)
{
	if (vaData.vt == VT_I2)
	{
		sData = vaData.iVal;
		return true;
	}
	else
	{
		return false;
	}
}
//
//
//
bool VariantConvert::Variant2long(VARIANT vaData, long& lData)
{
	if (vaData.vt == VT_I4)
	{
		lData = vaData.iVal;
		return true;
	}
	else
	{
		return false;
	}
}
//
//
//
bool VariantConvert::Variant2float(VARIANT vaData,float& fData)
{
	if (vaData.vt == VT_R4)
	{
		fData = vaData.iVal;
		return true;
	}
	else
	{
		return false;
	}
}
//
//
//
bool VariantConvert::Variant2double(VARIANT vaData,double& dData)
{
	if (vaData.vt == VT_R4)
	{
		dData = vaData.iVal;
		return true;
	}
	else
	{
		return false;
	}
}
//
//
//
void VariantConvert::Variant2Array(VARIANT vaArray,UINT& iDim,long& iDim1Num,long& iDim2Num, LPVOID *pData)
{
	//   //获得维数
	//UINT iDim =SafeArrayGetDim(vaStartMark.parray);
	iDim = SafeArrayGetDim(vaArray.parray);
	if (iDim != 2)
	{
		return;
	}
	//   //获得元素大小，这个没什么用
	UINT uEleSize = SafeArrayGetElemsize(vaArray.parray );

	// 获得一维的下界和上界
	long nDim1UBound;
	long nDim1LBound;
	SafeArrayGetUBound( vaArray.parray, 1, &nDim1UBound);
	SafeArrayGetLBound( vaArray.parray, 1, &nDim1LBound);
	//   //获得二维的下界和上界
	long nDim2UBound;
	long nDim2LBound;
	SafeArrayGetUBound( vaArray.parray, 2, &nDim2UBound);
	SafeArrayGetLBound( vaArray.parray, 2, &nDim2LBound);
	//
	//   //计算元素个数，分配空间使用
	//long nDim1Count = nDim1UBound - nDim1LBound +1;
	//long nDim2Count = nDim2UBound - nDim2LBound + 1;
	iDim1Num = nDim1UBound - nDim1LBound + 1;
	iDim2Num = nDim2UBound - nDim2LBound +1;

	int x = 0;
	int y = 0;
	long lIndex[2];
	for ( long nDim1 = nDim1LBound; nDim1 < nDim1UBound; nDim1++)
	{
		lIndex[0] =nDim1;
			y =0;
		for ( long nDim2 =nDim2LBound; nDim2 < nDim2UBound; nDim2++)
		{
			lIndex[1] =nDim2;
			SafeArrayGetElement (vaArray.parray, lIndex,pData[x*nDim2UBound+y]);
			y++;
		}
		x++;
	}

}
//
//
//
void VariantConvert::Variant2Array(VARIANT vaArray,long& lDimLenght,VOID** pData)
{
	//   //获得维数
	//UINT iDim =SafeArrayGetDim(vaStartMark.parray); 

	if (nDim != 1)
	{
		return;
	}
	//   //获得元素大小，这个没什么用
	UINT uEleSize = SafeArrayGetElemsize(vaArray.parray );
	// 获得一维的下界和上界
	long nDim1UBound;
	long nDim1LBound;
	SafeArrayGetUBound( vaArray.parray, 1, &nDim1UBound);
	SafeArrayGetLBound( vaArray.parray, 1, &nDim1LBound);
	//   //计算元素个数，分配空间使用
	//long nDim1Count = nDim1UBound - nDim1LBound +1;
	//long nDim2Count = nDim2UBound - nDim2LBound + 1;
	lDimLenght = nDim1UBound - nDim1LBound +1;
	// 转换
	int x = 0;
	int y = 0;
	long lIndex[1];
	for ( long nDim1 = nDim1LBound; nDim1 < nDim1UBound; nDim1++)
	{
			SafeArrayGetElement (vaArray.parray, lIndex,&pData[x]);
	}
	x++;
}