ADO中_variant_t变量的使用与转换

最新推荐文章于 2015-04-19 17:36:18 发布
最新推荐文章于 2015-04-19 17:36:18 发布
阅读量2.8k 收藏
点赞数 2
分类专栏： Visual Studio

转自：http://blog.csdn.net/zyq5945/article/details/5581453


下载 源代码

用ADO做数据库，有个麻烦的事情就是_variant_t变量的使用，使用本例中封装的CConvert类转换就方便了。

// Convert.h: interface for the CConvert class.
//
//
#if !defined(AFX_CONVERT_H__EC38F865_4607_4659_BAC8_AA6096C50EC7__INCLUDED_)
#define AFX_CONVERT_H__EC38F865_4607_4659_BAC8_AA6096C50EC7__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
//
// Construction/Destruction
/* 
* Copyright (c) 2010,ｚｙｑ５９４５@126.com
* All rights reserved. 
*  
* 文件名称：Convert.h 
* 文件标识：数据类型转换
* 摘    要：主要简化ADO中数据类型的转换 
*  
* 当前版本：1.0 
* 作    者：ｚｙｑ５９４５@126.com（注意把中文字符换成英文字符）
* 完成日期：2010年5月11日 
* 发布Blog：http://blog.csdn.net/zyq5945/ 
* 
*/ 
//
#define TS(value) CConvert::ToString(value)
class CConvert  
{
	
public:
	static CString ToString(BYTE btValue);
	static CString ToString(int iValue);
	static CString ToString(unsigned int iValue);
	static CString ToString(long lValue);
	static CString ToString(unsigned long lValue);
	static CString ToString(__int64 i64Value);
	static CString ToString(unsigned __int64 i64Value);
	static CString ToString(float fltValue);
	static CString ToString(double dblValue);
	static CString ToString(const COleDateTime& time);
	static CString ToString(const _variant_t& var);
public:
	static BYTE ToByte(LPCTSTR lpszValue);
	static int ToInt(LPCTSTR lpszValue);
	static unsigned int ToUInt(LPCTSTR lpszValue);
	static long ToLong(LPCTSTR lpszValue);
	static unsigned long ToULong(LPCTSTR lpszValue);
	static __int64 ToInt64(LPCTSTR lpszValue);
	static unsigned __int64 ToUInt64(LPCTSTR lpszValue);
	static float ToFloat(LPCTSTR lpszValue);
	static double ToDouble(LPCTSTR lpszValue);
	static COleDateTime ToTime(LPCTSTR lpszValue);
	static _variant_t ToVariant(const COleDateTime& time);
};
extern CConvert Convert;
#endif // !defined(AFX_CONVERT_H__EC38F865_4607_4659_BAC8_AA6096C50EC7__INCLUDED_)

// Convert.cpp: implementation of the CConvert class.
//
//
#include "stdafx.h"
#include "Convert.h"
#include <comutil.h>
#include <comdef.h>
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
//
// Construction/Destruction
/* 
* Copyright (c) 2010,ｚｙｑ５９４５@126.com
* All rights reserved. 
*  
* 文件名称：Convert.cpp 
* 文件标识：数据类型转换
* 摘    要：主要简化ADO中数据类型的转换 
*  
* 当前版本：1.0 
* 作    者：ｚｙｑ５９４５@126.com（注意把中文字符换成英文字符）
* 完成日期：2010年5月11日 
* 发布Blog：http://blog.csdn.net/zyq5945/
* 
*/ 
//
CConvert Convert;
CString CConvert::ToString(BYTE btValue)
{
	CString strValue;
	strValue.Format(_T("%d"), btValue);
	return strValue;
}
CString CConvert::ToString(int iValue)
{
	CString strValue;
	strValue.Format(_T("%d"), iValue);
	return strValue;
}
CString CConvert::ToString(unsigned int iValue)
{
	CString strValue;
	strValue.Format(_T("%u"), iValue);
	return strValue;
}
CString CConvert::ToString(long lValue)
{
	CString strValue;
	strValue.Format(_T("%d"), lValue);
	return strValue;
}
CString CConvert::ToString(unsigned long lValue)
{
	CString strValue;
	strValue.Format(_T("%u"), lValue);
	return strValue;
}
CString CConvert::ToString(__int64 i64Value)
{
	CString strValue;
	strValue.Format(_T("%I64d"), i64Value);
	return strValue;
}
CString CConvert::ToString(unsigned __int64 i64Value)
{
	CString strValue;
	strValue.Format(_T("%I64u"), i64Value);
	return strValue;
}
CString CConvert::ToString(float fltValue)
{
	CString strValue;
	strValue.Format(_T("%f"), fltValue);
	return strValue;
}
CString CConvert::ToString(double dblValue)
{
	CString strValue;
	strValue.Format(_T("%f"), dblValue);
	return strValue;
}
// 时间输出格式：2010-05-06 22:07:08
CString CConvert::ToString(const COleDateTime& time)
{
	CString strValue;
	strValue = time.Format(_T("%Y-%m-%d %H:%M:%S"));
	return strValue;
}
CString CConvert::ToString(const _variant_t& var)
{
	CString strValue;
	switch (var.vt)
	{
	case VT_BSTR: //字符串
	case VT_LPSTR:
	case VT_LPWSTR:
		strValue = (LPCTSTR)(_bstr_t)var;
		break;
	case VT_I1:   //无符号字符
	case VT_UI1:
		strValue.Format(_T("%d"), var.bVal);
		break;
	case VT_I2:   //短整型
		strValue.Format(_T("%d"), var.iVal);
		break;
	case VT_UI2:   //无符号短整型
		strValue.Format(_T("%u"), var.uiVal);
		break;
	case VT_INT: //整型
		strValue.Format(_T("%d"), var.intVal);
		break;
	case VT_I4:   //整型
	case VT_I8:   //长整型
		strValue.Format(_T("%d"), var.lVal);
		break;
	case VT_UINT:   //无符号整型
		strValue.Format(_T("%d"), var.uintVal);
		break;
	case VT_UI4:    //无符号整型
	case VT_UI8:    //无符号长整型
		strValue.Format(_T("%d"), var.ulVal);
		break;
	case VT_VOID:
		strValue.Format(_T("%08x"), var.byref);
		break;
	case VT_R4:   //浮点型
		strValue.Format(_T("%f"), var.fltVal);
		break;
	case VT_R8:   //双精度型
		strValue.Format(_T("%f"), var.dblVal);
		break;
	case VT_DECIMAL: //小数
		strValue.Format(_T("%f"), (double)var);
		break;
	case VT_CY:
		{
			COleCurrency cy = var.cyVal;
			strValue = cy.Format();
		}
		break;
	case VT_BLOB:
	case VT_BLOB_OBJECT:
	case 0x2011:
		strValue = _T("[BLOB]");
		break;
	case VT_BOOL:   //布尔型  
		strValue = var.boolVal ? _T("TRUE") : _T("FALSE");
		break;
	case VT_DATE: //日期型
		{
			DATE dt = var.date;
			COleDateTime da = COleDateTime(dt);
			strValue = da.Format(_T("%Y-%m-%d %H:%M:%S"));
		}
		break;
	case VT_NULL://NULL值
	case VT_EMPTY:   //空
		strValue = _T("");
		break;
	case VT_UNKNOWN:   //未知类型
	default:
		strValue = _T("VT_UNKNOW");
		break;
	}
	
	return strValue;
}
BYTE CConvert::ToByte(LPCTSTR lpszValue)
{
	BYTE btValue;
	btValue = (BYTE)_ttoi(lpszValue);
	return btValue;
}
int CConvert::ToInt(LPCTSTR lpszValue)
{
	int iValue;
	iValue = _ttoi(lpszValue);
	return iValue;
}
unsigned int CConvert::ToUInt(LPCTSTR lpszValue)
{
	unsigned int iValue;
	iValue = _ttoi(lpszValue);
	return iValue;
}
long CConvert::ToLong(LPCTSTR lpszValue)
{
	long lValue;
	lValue = _ttol(lpszValue);
	return lValue;
}
unsigned long CConvert::ToULong(LPCTSTR lpszValue)
{
	unsigned long lValue;
	lValue = _ttol(lpszValue);
	return lValue;
}
__int64 CConvert::ToInt64(LPCTSTR lpszValue)
{
	__int64 i64Value;
	i64Value = _ttoi64(lpszValue);
	return i64Value;
}
unsigned __int64 CConvert::ToUInt64(LPCTSTR lpszValue)
{
	unsigned __int64 i64Value;
	i64Value = _ttoi64(lpszValue);
	return i64Value;
}
float CConvert::ToFloat(LPCTSTR lpszValue)
{
	float fltValue;
#ifdef _MBCS
	fltValue = (float)atof(lpszValue);
#else
	fltValue = (float)wtof(lpszValue);
#endif
	return fltValue;
}
double CConvert::ToDouble(LPCTSTR lpszValue)
{
	double dblValue;
#ifdef _MBCS
	dblValue = atof(lpszValue);
#else
	dblValue = wtof(lpszValue);
#endif
	return dblValue;
}
// 时间格式例子：2010-05-06 22:07:08
//				 2010 05 06 22 07 08
//				 2010:05:06 22:07:08
//				 2010-05-06-22-07-08
// 只要是“- :”分割的时间格式都符合
COleDateTime CConvert::ToTime(LPCTSTR lpszValue)
{
	unsigned int iArray[6] = {2010, 5, 11, 12, 00, 00};
	int nIndex = 0;
#if _MSC_VER >= 1310  //VC6.0不支持CStringAlt::Tokenize
	CString strTmp;
	int curPos = 0;
	CString strValue(lpszValue);
	
	strTmp = strValue.Tokenize(_T("- :"),curPos);
	while (strTmp != _T("") && nIndex <6)
	{
		iArray[nIndex++] = ToUInt(strTmp);
		strTmp = strValue.Tokenize(_T("- :"), curPos);
	};
#else
	TCHAR tChar[MAX_PATH] = {0};
	TCHAR tCharTmp[MAX_PATH] = {0};
	TCHAR seps[]   = "- :";
	TCHAR *next_token = NULL;
	ASSERT(_tcslen(lpszValue) < MAX_PATH);
	RtlCopyMemory(tChar, lpszValue, _tcslen(lpszValue) * sizeof(TCHAR));
	next_token = _tcstok(tChar, seps);
	while ( next_token != NULL && nIndex <6)
	{
		iArray[nIndex++] = _ttoi(next_token);
		next_token = _tcstok( NULL, seps);
	}
	
#endif
	COleDateTime time(iArray[0], iArray[1], iArray[2],
		iArray[3], iArray[4], iArray[5]);
	return time;
}
_variant_t CConvert::ToVariant(const COleDateTime& time)
{
	_variant_t vtVal;
	
	vtVal.vt = VT_DATE;
	vtVal.date = time;
	return vtVal;
}

由于_variant_t重载了以下等号运算符，所以下面类型可以直接给_variant_t赋值 

VARIANT 
VARIANT* 
_variant_t
short 
long
float
double
CY
_bstr_t
wchar_t
char
IDispatch*
bool
IUnknown*
DECIMAL
BYTE
char
unsigned short
unsigned long
int
unsigned int
__int64
unsigned __int64

由于 COleDateTime  重载了以下等号运算符，所以下面类型可以直接给 COleDateTime  赋值 

VARIANT
DATE
time_t
__time64_t
SYSTEMTIME
FILETIME
UDATE

本例中CConvert类也增加了一个ToVariant函数把 COleDateTime转换为_variant_t类型变量 

	_variant_t varValue;
	CString strValue;
	COleDateTime dt;
	try
	{
		// 写入各字段值
		m_pRecordset->AddNew();
		// byte变量
		GetDlgItemText(IDC_EDIT1, strValue);
		varValue = CConvert::ToByte(strValue);	
		m_pRecordset->PutCollect("tByte", varValue);
		
		// int变量
		GetDlgItemText(IDC_EDIT2, strValue);
		varValue = (long)CConvert::ToInt(strValue);	
		m_pRecordset->PutCollect("tInt", varValue);
		// long变量
		GetDlgItemText(IDC_EDIT3, strValue);
		varValue = CConvert::ToLong(strValue);	
		m_pRecordset->PutCollect("tLong", varValue);
		// float变量
		GetDlgItemText(IDC_EDIT4, strValue);
		varValue = CConvert::ToFloat(strValue);	
		m_pRecordset->PutCollect("tFloat", varValue);
		// double变量
		GetDlgItemText(IDC_EDIT5, strValue);
		varValue = CConvert::ToDouble(strValue);	
		m_pRecordset->PutCollect("tDouble", varValue);
		// COleDateTime变量
		GetDlgItemText(IDC_EDIT6, strValue);
		dt = CConvert::ToTime(strValue);
		varValue = CConvert::ToVariant(dt);
		m_pRecordset->PutCollect("tTime", varValue);
		// bool变量
		GetDlgItemText(IDC_EDIT7, strValue);
		if (!strValue.CompareNoCase("TRUE"))
		{
			varValue = true;
		}
		else
		{
			varValue = false;
		}
		m_pRecordset->PutCollect("tBool", varValue);
		// 字符串变量
		GetDlgItemText(IDC_EDIT8, strValue);
		varValue = strValue;
		m_pRecordset->PutCollect("tText", varValue);
		m_pRecordset->Update();
		
		// 更新显示其库内容
		int nCurSel = m_list.GetItemCount();
		ADOListRecord();
		SetListSel(nCurSel);
	
		AfxMessageBox("插入成功!");
	}
	catch(_com_error& e)
	{
		dump_com_error(e);
	}

参考文献： ADO数据库编程-总结2
一下文章转自： http://hi.baidu.com/sunkanghome/blog/item/cea70101bdb177031d95839a.html

ADO数据库编程-总结2

三、ADO中的数据类型

        在使用ADO技术操作数据库时，存取变量的数据类型都是COM类型，这就要求经常在COM类型和普通数据类型之间进行类型转换。

         ADO中特有的数据类型包括以下三种：

         1）Variant

               该类型是结构化的数据类型，它包含值成员和数据类型成员。

               Variant可以包含许多其他的数据类型：如Variant、BSTR、Boolean、IDispatch或者IUnknow指针、货币、日期等。

                COM中由_variant_t 类来封装和管理Variant数据类型。

                在使用ADO对象模型操作数据库时，如果对象的某个方法或者属性操作数接受某个值，那么通常表明该值在_variant_t 中传递。

                注：在利用ADO对象进行C++数据类型的相关数据库操作（如将CString类型的值添加到数据库）时，需要进行强制类型转换

                       例如：对于   CString m_strName;

                                               m_pRecordset->PutCollect ( "姓名" , _variant_t ( m_strName ) );

          2）BSTR

                该类型 ( Basic STRing )也是结构化的数据类型，它包含字符串和字符串的长度。

                COM提供分配、处理和释放BSTR的方法，由_bstr_t类来封装和管理BSTR数据类型

                在使用ADO对象模型操作数据库时，如果对象的某个方法或者属性操作数接受一个字符串值，那么通常表明该值的形式为_bstr_t，而非一般的CString。

          3）SafeArray

                同样是一种结构化的数据类型，包含其它数据类型的数组。

                在使用ADO对象模型操作数据库时，如果对象的某个方法或者属性操作数接受或者返回一个数组，则数组类型只能是SafeArray，而非通常意义上的C/C++数组。

      通常，从数据库中取出的字段值大都在_variant_t中传递，下面给出从COM类型Variant向CString类型转换的通用函数。

      该函数将为数据库的访问和操作提供极大便利。

CString CLeftTreeView::VariantToCString(const _variant_t &var)
{
      CString strValue; 
     switch (var.vt)
     {
      case VT_BSTR: //字符串
      case VT_LPSTR:
      case VT_LPWSTR:
              strValue = (LPCTSTR)(_bstr_t)var;
              break;
      case VT_I1:   //无符号字符
      case VT_UI1:
             strValue.Format("%d", var.bVal);
            break;
      case VT_I2:   //短整型
            strValue.Format("%d", var.iVal);
           break;
       case VT_UI2:   //无符号短整型
              strValue.Format("%d", var.uiVal);
              break;
       case VT_INT: //整型
              strValue.Format("%d", var.intVal);
             break;
      case VT_I4:   //整型
      case VT_I8:   //长整型
              strValue.Format("%d", var.lVal);
              break;
       case VT_UINT:   //无符号整型
              strValue.Format("%d", var.uintVal);
              break;
     case VT_UI4:    //无符号整型
      case VT_UI8:    //无符号长整型
              strValue.Format("%d", var.ulVal);
              break;
      case VT_VOID:
              strValue.Format("%8x", var.byref);
              break;
      case VT_R4:   //浮点型
              strValue.Format("%.4f", var.fltVal);
             break;
      case VT_R8:   //双精度型
              strValue.Format("%.8f", var.dblVal);
              break;
      case VT_DECIMAL: //小数
               strValue.Format("%.8f", (double)var);
             break;
      case VT_CY:
                       {
                                   COleCurrency cy = var.cyVal;
                                  strValue = cy.Format();
                       }
                     break;
       case VT_BLOB:
      case VT_BLOB_OBJECT:
      case 0x2011:
                 strValue = "[BLOB]";
                 break;
      case VT_BOOL:   //布尔型  
                  strValue = var.boolVal ? "TRUE" : "FALSE";
                break;
      case VT_DATE: //日期型
                          {
                                   DATE dt = var.date;
                                   COleDateTime da = COleDateTime(dt); 
                                   strValue = da.Format("%Y-%m-%d %H:%M:%S");
                          }
                break;
      case VT_NULL://NULL值
      case VT_EMPTY:   //空
                    strValue = "";
                    break;
       case VT_UNKNOWN:   //未知类型
       default:
              strValue = "UN_KNOW";
              break;
      }
      return strValue;
}
半日闲心
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
_variant_t与其他数据类型的转换
白永辉的专栏
04-24 2万+
转自：http://kuaixingdong.blog.hexun.com/29627840_d.html 我们先看看COM所支持的一些类型的基本类： （微软提供，在comdef.h中定义） 在COM中使用的标准类Class如下所示： _bstr_t：对BSTR类型进行打包，并提供有用的操作和方法； _com_error：定义抛出的error对象； _com_ptr_t：封装COM接口
MFC ADO数据库编程中的_variant_t和_bstr_t类型
贝壳紫铃专栏
04-03 1419
_variant_t和_bstr_t这两个类分别封装并管理VARIANT和BSTR这两种数据类型，即是“Wrapper Class”VARIANT和BSTR这两种类型是COM中使用的数据类型，VARIANT类型是一个结构体，而BSTR is  A 32-bit character pointer。为了C++中的变量应用到ADO编程中，只能进行数据类型的转换。_variant_t和_bstr_t这两
Simple database Access using an ADO class使用ADO访问数据库
02-23
`创建一个variant变量，`CComPtr<ADOParameter> param;`创建一个参数对象，`param->Name = "@ParameterName";`设置参数名，`param->Value = paramValue;`设置参数值，`cmd->Parameters->Append(param);`将参数添加到...
在VBS中定义字节数组Byte()介绍
09-05
通常，VBS中的数据类型是Variant，它可以包含多种子类型，包括Byte。当涉及到字节子类型数组（VarType为8209），这意味着我们需要一个由Byte子类型组成的数组。 在VBS中，我们不能像在VB.NET或Visual Basic 6中那样...
电子商务系统规划与设计期末习题.doc
07-09
4. **HTML表单**：表单在HTML中使用`<form>`标签定义，提交方式包括POST和GET。常见的输入元素有单行文本框、单选按钮、复选框、下拉列表、滚动文本框和按钮。 5. **表格与标记**：表格通过`<table>`标签定义，行`...
如何在C 中将数据库数据分行和列保存到Excel中.doc
05-05
这种方法使用ActiveX Data Objects (ADO) 来直接从数据库读取数据，并将数据一次性导入到Excel工作表中。首先，你需要创建一个ADO连接，执行SQL查询获取数据，然后创建Excel对象并定义工作表范围。接着，使用`...
ADO 数据类型_bstr_t 和_variant_t
ChampionLai
07-01 2261
_bstr_t是BSTR_T这个数据类型对应的类 _variant_t是VARIANT这个数据类型的封装 Microsoft Specific Constructs a _bstr_t object. _bstr_t( ) throw( ); _bstr_t( const _bstr_t& s1 ) throw( ); _bstr_t(
vc Variant类型转换成CString函数
11-11
一个Variant类型转换成CString的函数，调试过，可以用。
ADO学习（五）_variant_t类型
liujiayu2的专栏
04-19 2475
Specifies the variant types. Syntax C++ Copy enum VARENUM { VT_EMPTY = 0, VT_NULL = 1, VT_I2 = 2, VT_I4 = 3, V
_variant_t 到　CString 转换
weixin_34268610的博客
09-11 194
variant_t 到　CString 转换 数据类型转换函数 CString CZjyDlg::VariantToString(VARIANT var) { CString strValue;          _variant_t var_t;          _bstr_t bstr_t;          time_t cur_time;          CTime t...
ADO 中 _variant_t 类型转换
行云织梦
04-18 752
CString m_UserName; _variant_t vstr = m_pRecordset->GetCollect("username"); m_UserName = vt.bstrVal; 或者 CString m_UserName; m_UserName=(LPCTSTR)(_bstr_t)(pRst->GetCollect(L"equip_desc")); 数值类型
ADO中_variant_t 的若干常用类型
Anliya的专栏
05-20 587
  unsigned   char   bVal;   VT_UI1       short   iVal;   VT_I2       long   lVal;     VT_I4         float   fltVal;     VT_R4       double   dblVal;     VT_R8      
_variant_t 转换成其他类型
techliangc的专栏
05-16 960
我定义了一组函数可以方便的实现_variant_t类型转换 //_variant_t转WORD类型 BOOL AfxVariantConvert(WORD& val, const _variant_t& vt) { if (vt.vt == VT_UI2) { val = (WORD)vt.uiVal; return TRUE; } else
_variant_t 数据类型学习
拼凑自我
01-16 1030
_variant_t是一个类，是VARIANT的完全包装类，它提供多种构造函数和数据转换函数。它继承自一个结构体，其结构如下： struct  tagVARIANT     {     union         {         struct  __tagVARIANT             {             VARTYPE vt;             WORD
_variant_t转int
最新发布
04-01
将_variant_t类型的变量转换为int类型可以使用以下方法： ```c++ _variant_t var = 10; // 定义_variant_t类型变量并赋值为10 int i = var.intVal; // 将_variant_t类型变量转换为int类型 ``` 或者使用以下方法： ```c++ _variant_t var = 10; // 定义_variant_t类型变量并赋值为10 int i = V_I4(&var); // 将_variant_t类型变量转换为int类型 ``` 其中，intVal是_variant_t类型的一个成员变量，可以直接访问，而V_I4是一个宏定义，用于获取_variant_t类型变量的整数值。如果_variant_t类型的变量不是int类型，则需要使用其他的成员变量或宏定义来进行类型转换。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值