//头文件
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++;
}

  

常用数据与VARIANT之间的转换---从网上整理的更多相关文章

  1. C# 实现Oracle中的数据与Excel之间的转换

    最近项目要求实现数据库之间数据在各个数据库之间导入导出,在此做个笔记 1. 将Oracle中的表导入到Excel中,反之亦然  private static readonly string conne ...

  2. 37.Activity之间的转换以及数据的传递(Intent)学习

      Intent简介:                                                                                在一个Androi ...

  3. C#字符串和数据之间的转换

    c#中不仅仅存在数值类型的数据之间的转换,字符串和数值之间也是可以互相转换的,只是方法不同而已. 1 数值型转换为字符型 数值型数据转换为字符串用ToString()方法即可实现 int num1=1 ...

  4. java基础类型数据与String类包装类之间的转换与理解

    数据类型转换一般分为三种: 在java中整型,实型,字符型视为简单数据类型,这些数据类型由低到高分别为:(byte,short,char--int-long-float-double) 简单数据类型之 ...

  5. JavaBean和json数据之间的转换(一)简单的JavaBean转换

    1.为什么要使用json? JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式,因为其高性能.可读性强的原因,成为了现阶段web开发中前后端交互数据的主要数据 ...

  6. java json数据转List对象的集合-----阿里巴巴插件---及原生json---JSON 与 对象 、集合 之间的转换 JSON字符串和java对象的互转【json-lib】

    List<RunfastFullLess> list=(List<RunfastFullLess>)JSONArray.parseObject(activity.getFull ...

  7. JavaBean和json数据之间的转换(二)含有date类型的JavaBean

    1.前言 上次讲了简单的JavaBean和json格式之间的转换,代码很简单,但是实际过程中,往往用到的JavaBean都是比较复杂的,其他的字段还好,如果JavaBean中包含了date类型的字段, ...

  8. CString-int-string-char-BSTR之间的转换

    一.CString, int, string, char*之间的转换 string 转 CString CString.Format("%s", string.c_str());c ...

  9. Java基础——基本类型和包装类、基本类型和字符串之间的转换

    基本类型和包装类之间的转换 基本类型和包装类之间经常需要互相转换,以 Integer 为例(其他几个包装类的操作雷同哦): 在 JDK1.5 引入自动装箱和拆箱的机制后,包装类和基本类型之间的转换就更 ...

随机推荐

  1. HW4.3

    public class Solution { public static void main(String[] args) { final double POUND_PER_KILOGRAM = 2 ...

  2. algorithm@ Matrix fast power

    一. 什么是快速幂: 快速幂顾名思义,就是快速算某个数的多少次幂.其时间复杂度为 O(log₂N), 与朴素的O(N)相比效率有了极大的提高.一般一个矩阵的n次方,我们会通过连乘n-1次来得到它的n次 ...

  3. 关于Redis的常识(推荐)

    原文出处: https://github.com/springside/springside4/wiki/redis 版本:V3.0.3 2013-8-1 (@江南白衣版权所有,转载请保留出处) 1. ...

  4. [一]初识SpringMVC

    是什么? web开发框架 为什么用? 功能强大 怎么做? 1.导入jar包 2.配置web.xml <?xml version="1.0" encoding="UT ...

  5. codis集群和redis cluster的优劣对比

    1.codis架构如下: (1)Codis是一整套缓存解决方案,包含高可用.数据分片.监控.动态扩态 etc..走的是 Apps->代理->redis cluster,一定规模后基本都采用 ...

  6. Dublin Core

    DC(Dublin Core) 是数字图书馆中使用的一组简单的包括15个“核心元素”的元数据元素集合,主要用于描述数字对象.馆藏管理和元数据交换. 这15项元数据不仅适用于电子文献目录,也适用于各类电 ...

  7. HDU 4465 - Candy(概率与数学优化)

    2012成都Regional的B题,花了一个小时推出了式子,但是搞了好久发现都控制不了精度,后来突然想到组合数可以用log优化,改了之后就AC了 比较水的概率题 #include <stdio. ...

  8. patchdiff2 函数比较插件

    https://code.google.com/archive/p/patchdiff2/downloads

  9. ASP.NET 未被授权访问所请求的资源。请考虑授予 ASP.NET 请求标识访问此资源的权限

    开发了一个导入TXT文件的功能,执行过程中出错.提示:.....ASP.NET 未被授权访问所请求的资源.请考虑授予 ASP.NET 请求标识访问此资源的权限.ASP.NET 有一个在应用程序没有模拟 ...

  10. I'm back

    亲爱的博友们, 请忽略这一条, 这只是我个人的一个记录.