MFC之ADO数据库快速编程

最新推荐文章于 2016-11-03 11:05:38 发布
转载 最新推荐文章于 2016-11-03 11:05:38 发布 · 536 阅读 · 0

本文介绍了一种使用MFC结合ADO进行数据库快速编程的方法，包括创建数据记录类、生成数据库操作代码以及如何实现增删改查等功能。
MFC之ADO数据库快速编程
2012-10-16 23:37 11847人阅读 评论(25) 收藏 举报
分类：
作者同类文章 X

    版权声明：本文为博主原创文章，未经博主允许不得转载。

    源码Demo下载

    ADO数据库操作综合起来就是增删改查，而且这几个流程都是固定的。

    查询：连接数据库-->打开记录集-->遍历记录集并获取记录内容

    插入：连接数据库-->打开记录集-->插入数据库记录-->将记录保存到数据库

    更新：连接数据库-->打开记录集-->遍历记录集并更新记录-->将记录保存到数据库

    删除：连接数据库-->执行删除的SQL语句


    将表的一行数据内容封装成一个数据记录类，该数据记录类提供三个接口：

    AdoGetPrimaryKey：一个获取数据记录类主键值接口，主要是为了数据记录做定位，然后做相应的操作

    AdoGetRecord：一个获取当前记录集当前行内容的接口，查询遍历记录集的时候调用这个接口即可把记录集当前行内容存放数据记录类对象中

    AdoSetRecord：一个将数据记录类对象更新到记录集当前行，插入的时候将数据记录类对象更新到记录集当前行即可，更新的时候通过调用AdoGetPrimaryKey接口获取对应的数据记录类对象，将数据记录类对象更新到记录集当前行


    需要做到快速，还需要一个小工具ADO助手来帮忙根据SQL内容生成数据记录类，具体操作及使用请参考《如何使用ADO助手生成数据库代码》。

    具体的使用步骤：

    1.将本例中的数据库封装类拷贝到你MFC工程目录下，并用include包含到预处理头文件stdafx.h中

    [cpp] view plain copy print ?
    1. #include "Ado/Ado.h"  
    #include "Ado/Ado.h"

    2.将用小工具生成的数据库类也添加到工程，本例中生成的数据库类是CDBDemo

    [sql] view plain copy print ?
    1. -- SQL SERVER 2005建表SQL语句  
    2. CREATE TABLE [dbo].[tbl_Demo](  
    3.     [ID] [int] IDENTITY(1,1) NOT NULL,  
    4.     [Guid] [nvarchar](80) NOT NULL,  
    5.     [Name] [nvarchar](20) NULL,  
    6.     [Age] [int] NULL,  
    7.     [Photo] [image] NULL,  
    8.  CONSTRAINT [PK_tbl_Demo] PRIMARY KEY CLUSTERED   
    9. (  
    10.     [Guid] ASC  
    11. )WITH (IGNORE_DUP_KEY = OFF) ON [PRIMARY]  
    12. ) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]  
    -- SQL SERVER 2005建表SQL语句
CREATE TABLE [dbo].[tbl_Demo](
	[ID] [int] IDENTITY(1,1) NOT NULL,
	[Guid] [nvarchar](80) NOT NULL,
	[Name] [nvarchar](20) NULL,
	[Age] [int] NULL,
	[Photo] [image] NULL,
 CONSTRAINT [PK_tbl_Demo] PRIMARY KEY CLUSTERED 
(
	[Guid] ASC
)WITH (IGNORE_DUP_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]

    用ADO助手生成的MFC数据库代码如下，支持二进制字段。

    生成的数据库类还需要增加一个成员函数CString AdoGetPrimaryKey() const，该函数返回表主键值，最终数据记录类如下：

    [cpp] view plain copy print ?
    1. /*---------------------------------------------------------------------------------------------------------------- 
    2. Version:    AdoAssist 1.20 
    3.    Time:    2012-08-16 09:37:11 
    4.     SQL:    SELECT * FROM tbl_Demo 
    5. ----------------------------------------------------------------------------------------------------------------*/  
    6. #pragma once  
    7.   
    8. class CDBDemo  
    9. {  
    10. public:  
    11.     long            m_lID;  //0 ID  adInteger  
    12.     CString         m_strGuid;  //1 Guid    adVarWChar  
    13.     CString         m_strName;  //2 Name    adVarWChar  
    14.     long            m_lAge; //3 Age adInteger  
    15.     //CAdoByteArray         m_brPhoto;  //4 Photo   adLongVarBinary  
    16.     CAdoBinaryRes           m_brPhoto;  //4 Photo   adLongVarBinary  
    17.   
    18. public:  
    19.     long GetID() const  
    20.     {  
    21.         return this->m_lID;  
    22.     }  
    23.   
    24.     void GetID(long& tID) const  
    25.     {  
    26.         tID = this->m_lID;  
    27.     }  
    28.   
    29.     void SetID(const long& tID)  
    30.     {  
    31.         this->m_lID = tID;  
    32.     }  
    33.   
    34.     CString GetGuid() const  
    35.     {  
    36.         return this->m_strGuid;  
    37.     }  
    38.   
    39.     void GetGuid(CString& tGuid) const  
    40.     {  
    41.         tGuid = this->m_strGuid;  
    42.     }  
    43.   
    44.     void SetGuid(const CString& tGuid)  
    45.     {  
    46.         this->m_strGuid = tGuid;  
    47.     }  
    48.   
    49.     CString GetName() const  
    50.     {  
    51.         return this->m_strName;  
    52.     }  
    53.   
    54.     void GetName(CString& tName) const  
    55.     {  
    56.         tName = this->m_strName;  
    57.     }  
    58.   
    59.     void SetName(const CString& tName)  
    60.     {  
    61.         this->m_strName = tName;  
    62.     }  
    63.   
    64.     long GetAge() const  
    65.     {  
    66.         return this->m_lAge;  
    67.     }  
    68.   
    69.     void GetAge(long& tAge) const  
    70.     {  
    71.         tAge = this->m_lAge;  
    72.     }  
    73.   
    74.     void SetAge(const long& tAge)  
    75.     {  
    76.         this->m_lAge = tAge;  
    77.     }  
    78.   
    79.     /*CAdoBinaryRes GetPhoto() const 
    80.     { 
    81.         return this->m_brPhoto; 
    82.     } 
    83.  
    84.     void GetPhoto(CAdoBinaryRes& tPhoto) const 
    85.     { 
    86.         tPhoto = this->m_brPhoto; 
    87.     } 
    88.  
    89.     void SetPhoto(const CAdoBinaryRes& tPhoto) 
    90.     { 
    91.         this->m_brPhoto = tPhoto; 
    92.     } 
    93. */  
    94.   
    95. public:  
    96.     // Database Interface  
    97.     CString AdoGetPrimaryKey() const  
    98.     {  
    99.         return GetGuid();  
    100.     }  
    101.     bool AdoGetRecord(const CAdoRecordset& rs, DWORD dwFlag = 0);  
    102.     bool AdoSetRecord(const CAdoRecordset& rs, DWORD dwFlag = 0) const;  
    103. };  
    104. #pragma warning( push )  
    105. #pragma warning(disable:4100)  
    106. // Database Interface  
    107. inline bool CDBDemo::AdoGetRecord(const CAdoRecordset& rs, DWORD dwFlag)  
    108. {  
    109.     ADO_GETFIELDVALUE(_T("ID"), m_lID); //0  
    110.     ADO_GETFIELDVALUE(_T("Guid"), m_strGuid);   //1  
    111.     ADO_GETFIELDVALUE(_T("Name"), m_strName);   //2  
    112.     ADO_GETFIELDVALUE(_T("Age"), m_lAge);   //3  
    113.     ADO_GETFIELDVALUE(_T("Photo"), m_brPhoto);  //4  
    114.   
    115.     /* 
    116.     ADO_GETFIELDVALUE((long)0, m_lID);  //ID 
    117.     ADO_GETFIELDVALUE((long)1, m_strGuid);  //Guid 
    118.     ADO_GETFIELDVALUE((long)2, m_strName);  //Name 
    119.     ADO_GETFIELDVALUE((long)3, m_lAge); //Age 
    120.     ADO_GETFIELDVALUE((long)4, m_brPhoto);  //Photo 
    121.     */  
    122.   
    123.     return true;  
    124. }  
    125.   
    126. // Database Interface  
    127. inline bool CDBDemo::AdoSetRecord(const CAdoRecordset& rs, DWORD dwFlag) const  
    128. {  
    129.     //ADO_SETFIELDVALUE(_T("ID"), m_lID);   //0  
    130.     ADO_SETFIELDVALUE(_T("Guid"), m_strGuid);   //1  
    131.     ADO_SETFIELDVALUE(_T("Name"), m_strName);   //2  
    132.     ADO_SETFIELDVALUE(_T("Age"), m_lAge);   //3  
    133.     ADO_SETFIELDVALUE(_T("Photo"), m_brPhoto);  //4  
    134.   
    135.     /* 
    136.     //ADO_SETFIELDVALUE((long)0, m_lID);    //ID 
    137.     ADO_SETFIELDVALUE((long)1, m_strGuid);  //Guid 
    138.     ADO_SETFIELDVALUE((long)2, m_strName);  //Name 
    139.     ADO_SETFIELDVALUE((long)3, m_lAge); //Age 
    140.     ADO_SETFIELDVALUE((long)4, m_brPhoto);  //Photo 
    141.     */  
    142.   
    143.     return true;  
    144. }  
    145.   
    146. #pragma warning( pop )  
    /*----------------------------------------------------------------------------------------------------------------
Version:	AdoAssist 1.20
   Time:	2012-08-16 09:37:11
    SQL:	SELECT * FROM tbl_Demo
----------------------------------------------------------------------------------------------------------------*/
#pragma once

class CDBDemo
{
public:
	long			m_lID;	//0	ID	adInteger
	CString			m_strGuid;	//1	Guid	adVarWChar
	CString			m_strName;	//2	Name	adVarWChar
	long			m_lAge;	//3	Age	adInteger
	//CAdoByteArray			m_brPhoto;	//4	Photo	adLongVarBinary
	CAdoBinaryRes			m_brPhoto;	//4	Photo	adLongVarBinary

public:
	long GetID() const
	{
		return this->m_lID;
	}

	void GetID(long& tID) const
	{
		tID = this->m_lID;
	}

	void SetID(const long& tID)
	{
		this->m_lID = tID;
	}

	CString GetGuid() const
	{
		return this->m_strGuid;
	}

	void GetGuid(CString& tGuid) const
	{
		tGuid = this->m_strGuid;
	}

	void SetGuid(const CString& tGuid)
	{
		this->m_strGuid = tGuid;
	}

	CString GetName() const
	{
		return this->m_strName;
	}

	void GetName(CString& tName) const
	{
		tName = this->m_strName;
	}

	void SetName(const CString& tName)
	{
		this->m_strName = tName;
	}

	long GetAge() const
	{
		return this->m_lAge;
	}

	void GetAge(long& tAge) const
	{
		tAge = this->m_lAge;
	}

	void SetAge(const long& tAge)
	{
		this->m_lAge = tAge;
	}

	/*CAdoBinaryRes GetPhoto() const
	{
		return this->m_brPhoto;
	}

	void GetPhoto(CAdoBinaryRes& tPhoto) const
	{
		tPhoto = this->m_brPhoto;
	}

	void SetPhoto(const CAdoBinaryRes& tPhoto)
	{
		this->m_brPhoto = tPhoto;
	}
*/

public:
	// Database Interface
	CString AdoGetPrimaryKey() const
	{
		return GetGuid();
	}
	bool AdoGetRecord(const CAdoRecordset& rs, DWORD dwFlag = 0);
	bool AdoSetRecord(const CAdoRecordset& rs, DWORD dwFlag = 0) const;
};
#pragma warning( push )
#pragma warning(disable:4100)
// Database Interface
inline bool CDBDemo::AdoGetRecord(const CAdoRecordset& rs, DWORD dwFlag)
{
	ADO_GETFIELDVALUE(_T("ID"), m_lID);	//0
	ADO_GETFIELDVALUE(_T("Guid"), m_strGuid);	//1
	ADO_GETFIELDVALUE(_T("Name"), m_strName);	//2
	ADO_GETFIELDVALUE(_T("Age"), m_lAge);	//3
	ADO_GETFIELDVALUE(_T("Photo"), m_brPhoto);	//4

	/*
	ADO_GETFIELDVALUE((long)0, m_lID);	//ID
	ADO_GETFIELDVALUE((long)1, m_strGuid);	//Guid
	ADO_GETFIELDVALUE((long)2, m_strName);	//Name
	ADO_GETFIELDVALUE((long)3, m_lAge);	//Age
	ADO_GETFIELDVALUE((long)4, m_brPhoto);	//Photo
	*/

	return true;
}

// Database Interface
inline bool CDBDemo::AdoSetRecord(const CAdoRecordset& rs, DWORD dwFlag) const
{
	//ADO_SETFIELDVALUE(_T("ID"), m_lID);	//0
	ADO_SETFIELDVALUE(_T("Guid"), m_strGuid);	//1
	ADO_SETFIELDVALUE(_T("Name"), m_strName);	//2
	ADO_SETFIELDVALUE(_T("Age"), m_lAge);	//3
	ADO_SETFIELDVALUE(_T("Photo"), m_brPhoto);	//4

	/*
	//ADO_SETFIELDVALUE((long)0, m_lID);	//ID
	ADO_SETFIELDVALUE((long)1, m_strGuid);	//Guid
	ADO_SETFIELDVALUE((long)2, m_strName);	//Name
	ADO_SETFIELDVALUE((long)3, m_lAge);	//Age
	ADO_SETFIELDVALUE((long)4, m_brPhoto);	//Photo
	*/

	return true;
}

#pragma warning( pop )


    3.添加一个业务数据库类CDBBusiness，该类从CAdoDatabase派生，并把CDBDemo类的头文件用include包含到业务数据库类CDBBusiness的头文件中


    4.在业务数据库类CDBBusiness中编写连接数据库代码

    [cpp] view plain copy print ?
    1. BOOL CDBBusiness::Connect(void)  
    2. {  
    3.     CString strAccessFile;  
    4.     GetModuleFileName(NULL, strAccessFile.GetBuffer(MAX_PATH), MAX_PATH);  
    5.     strAccessFile.ReleaseBuffer();  
    6.     // 获取程序的运行目录  
    7.     strAccessFile = strAccessFile.Left(strAccessFile.ReverseFind('\\')+1);  
    8.       
    9.     CString strConnction;  
    10.   
    11.     strAccessFile += _T("Demo.mdb");  
    12.     strConnction.Format(_T("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=%s;Persist Security Info=False"),  
    13.         strAccessFile);  
    14.   
    15.     return Open(strConnction);  
    16. }  
    BOOL CDBBusiness::Connect(void)
{
	CString strAccessFile;
	GetModuleFileName(NULL, strAccessFile.GetBuffer(MAX_PATH), MAX_PATH);
	strAccessFile.ReleaseBuffer();
	// 获取程序的运行目录
	strAccessFile = strAccessFile.Left(strAccessFile.ReverseFind('\\')+1);
	
	CString strConnction;

	strAccessFile += _T("Demo.mdb");
	strConnction.Format(_T("Provider=Microsoft.Jet.OLEDB.4.0;Data Source=%s;Persist Security Info=False"),
		strAccessFile);

	return Open(strConnction);
}

    5.数据库增删查改操作

    需要用到两个宏，一个声明宏ADO_DECLARE，一个实现宏ADO_IMPLEMENT

    [cpp] view plain copy print ?
    1. /* 
    2. <summary> 
    3. 声明数据类与数据库的交互 
    4. </summary> 
    5. <param name="_FunPrefix">添加的成员函数名修饰前缀</param> 
    6. <param name="_FunSuffix">添加的成员函数名修饰后缀</param> 
    7. <param name="_DbClass">数据类</param> 
    8. */  
    9. #define ADO_DECLARE(_FunPrefix, _FunSuffix, _DbClass)                                                                                                               \  
    10.     typedef std::vector<_DbClass> Vector_##_DbClass;                                                                                                              \  
    11.     typedef std::vector<_DbClass>::iterator _DbClass##_Iterator;                                                                                                  \  
    12.     typedef const Vector_##_DbClass Const_Vector_##_DbClass;                                                                                                        \  
    13.     typedef Vector_##_DbClass::const_iterator Const_##_DbClass##_Iterator;                                                                                          \  
    14.     bool _FunPrefix##Select##_FunSuffix(Vector_##_DbClass& rData, LPCTSTR lpszCondition= _T(""), LPCTSTR lpszTop = _T(""), DWORD dwFlag = 0) const;                 \  
    15.     bool _FunPrefix##Update##_FunSuffix(const _DbClass& rData, DWORD dwFlag = 0) const;                                                                             \  
    16.     bool _FunPrefix##Save##_FunSuffix(const _DbClass& rData, DWORD dwFlag = 0) const;                                                                               \  
    17.     bool _FunPrefix##Insert##_FunSuffix(const _DbClass& rData, DWORD dwFlag = 0) const;                                                                             \  
    18.     bool _FunPrefix##Delete##_FunSuffix(const _DbClass& rData) const;                                                                                               \  
    19.     bool _FunPrefix##Count##_FunSuffix(const _DbClass& rData, long &lCount) const;                                                                                  \  
    20.     bool _FunPrefix##Count##_DbClass##_FunSuffix(long &lCount, LPCTSTR lpszWhere= _T("")) const;                                                                    \  
    21.     bool _FunPrefix##Delete##_DbClass##_FunSuffix(LPCTSTR lpszWhere= _T("")) const;                                                                                 \  
    22.     bool _FunPrefix##SelectOrder##_FunSuffix(Vector_##_DbClass& rData, LPCTSTR lpszWhere= _T(""), DWORD dwFlag = 0) const;                                          \  
    23.     bool _FunPrefix##Update##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;                                                                    \  
    24.     bool _FunPrefix##UpdateBatch##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;                                                               \  
    25.     bool _FunPrefix##Insert##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;                                                                    \  
    26.     bool _FunPrefix##InsertBatch##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;                                                               \  
    27.     bool _FunPrefix##Count##_FunSuffix(Const_Vector_##_DbClass& rData, long &lCount) const;                                                                         \  
    28.     bool _FunPrefix##Delete##_FunSuffix(Const_Vector_##_DbClass& rData) const;                                                                                      \  
    29.     bool _FunPrefix##Select##_FunSuffix(_DbClass& rData, DWORD dwFlag = 0) const;                                                                                   \  
    30.     bool _FunPrefix##Save##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;                                                                      \  
    31.     bool _FunPrefix##SaveBatch##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;  
    /*
<summary>
声明数据类与数据库的交互
</summary>
<param name="_FunPrefix">添加的成员函数名修饰前缀</param>
<param name="_FunSuffix">添加的成员函数名修饰后缀</param>
<param name="_DbClass">数据类</param>
*/
#define ADO_DECLARE(_FunPrefix, _FunSuffix, _DbClass)																												\
	typedef std::vector<_DbClass> Vector_##_DbClass;																												\
	typedef std::vector<_DbClass>::iterator _DbClass##_Iterator;																									\
	typedef const Vector_##_DbClass Const_Vector_##_DbClass;																										\
	typedef Vector_##_DbClass::const_iterator Const_##_DbClass##_Iterator;																							\
	bool _FunPrefix##Select##_FunSuffix(Vector_##_DbClass& rData, LPCTSTR lpszCondition= _T(""), LPCTSTR lpszTop = _T(""), DWORD dwFlag = 0) const;					\
	bool _FunPrefix##Update##_FunSuffix(const _DbClass& rData, DWORD dwFlag = 0) const;																				\
	bool _FunPrefix##Save##_FunSuffix(const _DbClass& rData, DWORD dwFlag = 0) const;																				\
	bool _FunPrefix##Insert##_FunSuffix(const _DbClass& rData, DWORD dwFlag = 0) const;																				\
	bool _FunPrefix##Delete##_FunSuffix(const _DbClass& rData) const;																								\
	bool _FunPrefix##Count##_FunSuffix(const _DbClass& rData, long &lCount) const;																					\
	bool _FunPrefix##Count##_DbClass##_FunSuffix(long &lCount, LPCTSTR lpszWhere= _T("")) const;																	\
	bool _FunPrefix##Delete##_DbClass##_FunSuffix(LPCTSTR lpszWhere= _T("")) const;																					\
	bool _FunPrefix##SelectOrder##_FunSuffix(Vector_##_DbClass& rData, LPCTSTR lpszWhere= _T(""), DWORD dwFlag = 0) const;											\
	bool _FunPrefix##Update##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;																	\
	bool _FunPrefix##UpdateBatch##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;																\
	bool _FunPrefix##Insert##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;																	\
	bool _FunPrefix##InsertBatch##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;																\
	bool _FunPrefix##Count##_FunSuffix(Const_Vector_##_DbClass& rData, long &lCount) const;																			\
	bool _FunPrefix##Delete##_FunSuffix(Const_Vector_##_DbClass& rData) const;																						\
	bool _FunPrefix##Select##_FunSuffix(_DbClass& rData, DWORD dwFlag = 0) const;																					\
	bool _FunPrefix##Save##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;																		\
	bool _FunPrefix##SaveBatch##_FunSuffix(Const_Vector_##_DbClass& rData, DWORD dwFlag = 0) const;
    [cpp] view plain copy print ?
    1. /* 
    2. <summary> 
    3. 实现数据类与数据库的交互 
    4. </summary> 
    5. <param name="_FunPrefix">添加的成员函数名修饰前缀</param> 
    6. <param name="_FunSuffix">添加的成员函数名修饰后缀</param> 
    7. <param name="_ClasName">业务数据库类，必须从CAdoDatabase派生</param> 
    8. <param name="_DbClass">数据类</param> 
    9. <param name="_TableName">数据表名称</param> 
    10. <param name="_PrimeKey">数据表名主键名称</param> 
    11. <param name="_FieldList">数据库字段，偷懒的话直接用“"*"”</param> 
    12. */  
    13. #define ADO_IMPLEMENT(_FunPrefix, _FunSuffix, _ClasName, _DbClass, _TableName, _PrimeKey, _FieldList)     
    /*
<summary>
实现数据类与数据库的交互
</summary>
<param name="_FunPrefix">添加的成员函数名修饰前缀</param>
<param name="_FunSuffix">添加的成员函数名修饰后缀</param>
<param name="_ClasName">业务数据库类，必须从CAdoDatabase派生</param>
<param name="_DbClass">数据类</param>
<param name="_TableName">数据表名称</param>
<param name="_PrimeKey">数据表名主键名称</param>
<param name="_FieldList">数据库字段，偷懒的话直接用“"*"”</param>
*/
#define ADO_IMPLEMENT(_FunPrefix, _FunSuffix, _ClasName, _DbClass, _TableName, _PrimeKey, _FieldList)

    本例子如下添加声明和实现
    [cpp] view plain copy print ?
    1. ADO_DECLARE(_, _, CDBDemo);  
    ADO_DECLARE(_, _, CDBDemo);
    [cpp] view plain copy print ?
    1. ADO_IMPLEMENT(_, _, CDBBusiness, CDBDemo, "tbl_Demo", "Guid", "Id, Guid, Name, Age, Photo");  
    ADO_IMPLEMENT(_, _, CDBBusiness, CDBDemo, "tbl_Demo", "Guid", "Id, Guid, Name, Age, Photo");

    本例中上面两个宏编译后实现了如下函数

    A.查询

    [cpp] view plain copy print ?
    1. /* 
    2. <summary> 
    3. 通过主键定位获取单个记录 
    4. </summary> 
    5. <param name="rData">记录的类对象</param> 
    6. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    7. <returns>是否执行成功</returns> 
    8. */  
    9. bool _Select_(CDBDemo& rData, DWORD dwFlag = 0) const;  
    10.   
    11. /* 
    12. <summary> 
    13. 获取多个记录 
    14. 注：请调用Count(*)计算个数或者直接定量,调用std::vector<T>::reserve预留内存空间，否则可能有性能影响 
    15. </summary> 
    16. <param name="rData">记录的类向量对象</param> 
    17. <param name="lpszCondition">SQL语句的WHERE子句,ORDER子句或者LIMIT子句任意组合，为空则查询整个表</param> 
    18. <param name="lpszTop">SQL语句的TOP子句</param> 
    19. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    20. <returns>是否执行成功</returns> 
    21. */  
    22. bool _Select_(std::vector<CDBDemo>& rData, LPCTSTR lpszCondition= _T(""),   
    23.     LPCTSTR lpszTop = _T(""), DWORD dwFlag = 0) const;  
    24.       
    25. /* 
    26. <summary> 
    27. 获取表数据，数据按主键升序排列 
    28. 注：请调用Count(*)计算个数或者直接定量,调用std::vector<T>::reserve预留内存空间，否则可能有性能影响 
    29. </summary> 
    30. <param name="rData">记录的类向量对象</param> 
    31. <param name="lpszWhere">SQL语句的WHERE子句</param> 
    32. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    33. <returns>是否执行成功</returns> 
    34. */  
    35. bool _SelectOrder_(std::vector<CDBDemo>& rData, LPCTSTR lpszWhere= _T(""), DWORD dwFlag = 0) const;  
    	/*
	<summary>
	通过主键定位获取单个记录
	</summary>
	<param name="rData">记录的类对象</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _Select_(CDBDemo& rData, DWORD dwFlag = 0) const;
	
	/*
	<summary>
	获取多个记录
	注：请调用Count(*)计算个数或者直接定量,调用std::vector<T>::reserve预留内存空间，否则可能有性能影响
	</summary>
	<param name="rData">记录的类向量对象</param>
	<param name="lpszCondition">SQL语句的WHERE子句,ORDER子句或者LIMIT子句任意组合，为空则查询整个表</param>
	<param name="lpszTop">SQL语句的TOP子句</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _Select_(std::vector<CDBDemo>& rData, LPCTSTR lpszCondition= _T(""), 
		LPCTSTR lpszTop = _T(""), DWORD dwFlag = 0) const;
		
	/*
	<summary>
	获取表数据，数据按主键升序排列
	注：请调用Count(*)计算个数或者直接定量,调用std::vector<T>::reserve预留内存空间，否则可能有性能影响
	</summary>
	<param name="rData">记录的类向量对象</param>
	<param name="lpszWhere">SQL语句的WHERE子句</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _SelectOrder_(std::vector<CDBDemo>& rData, LPCTSTR lpszWhere= _T(""), DWORD dwFlag = 0) const;
    B.计数

    [cpp] view plain copy print ?
    1. /* 
    2. <summary> 
    3. 计算当前主键在表中个数，为0或者1 
    4. </summary> 
    5. <param name="rData">记录的类对象</param> 
    6. <param name="lCount">返回计算的个数，为0或者1</param> 
    7. <returns>是否执行成功</returns> 
    8. */  
    9. bool _Count_(const CDBDemo& rData, long &lCount) const;  
    10.   
    11.       
    12. /* 
    13. <summary> 
    14. 计算类向量对象在数据库中的个数 
    15. </summary> 
    16. <param name="rData">记录的类向量对象</param> 
    17. <param name="lCount">计算类向量对象在数据库中的个数</param> 
    18. <returns>是否执行成功</returns> 
    19. */  
    20. bool _Count_(const std::vector<CDBDemo>& rData, long &lCount) const;  
    21.   
    22.   
    23. /* 
    24. <summary> 
    25. 计算表中数据个数 
    26. </summary> 
    27. <param name="lCount">返回计算的个数</param> 
    28. <param name="lpszWhere">SQL语句的WHERE子句</param> 
    29. <returns>是否执行成功</returns> 
    30. */  
    31. bool _CountCDBDemo_(long &lCount, LPCTSTR lpszWhere= _T("")) const;   
    	/*
	<summary>
	计算当前主键在表中个数，为0或者1
	</summary>
	<param name="rData">记录的类对象</param>
	<param name="lCount">返回计算的个数，为0或者1</param>
	<returns>是否执行成功</returns>
	*/
	bool _Count_(const CDBDemo& rData, long &lCount) const;
	
		
	/*
	<summary>
	计算类向量对象在数据库中的个数
	</summary>
	<param name="rData">记录的类向量对象</param>
	<param name="lCount">计算类向量对象在数据库中的个数</param>
	<returns>是否执行成功</returns>
	*/
	bool _Count_(const std::vector<CDBDemo>& rData, long &lCount) const;

	
	/*
	<summary>
	计算表中数据个数
	</summary>
	<param name="lCount">返回计算的个数</param>
	<param name="lpszWhere">SQL语句的WHERE子句</param>
	<returns>是否执行成功</returns>
	*/
	bool _CountCDBDemo_(long &lCount, LPCTSTR lpszWhere= _T("")) const;
    C.保存（有则更新无则插入）

    [cpp] view plain copy print ?
    1. /* 
    2. <summary> 
    3. 通过主键定位记录，没有则插入，有则更新 
    4. </summary> 
    5. <param name="rData">记录的类对象</param> 
    6. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    7. <returns>是否执行成功</returns> 
    8. */  
    9. bool _Save_(const CDBDemo& rData, DWORD dwFlag = 0) const;  
    10.   
    11. /* 
    12. <summary> 
    13. 用Update进行插入或者更新多个记录 
    14. </summary> 
    15. <param name="rData">记录的类向量对象</param> 
    16. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    17. <returns>是否执行成功</returns> 
    18. */  
    19. bool _Save_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;  
    20.   
    21. /* 
    22. <summary> 
    23. 用UpdateBatch进行批量插入或者更新多个记录 
    24. </summary> 
    25. <param name="rData">记录的类向量对象</param> 
    26. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    27. <returns>是否执行成功</returns> 
    28. */  
    29. bool _SaveBatch_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;  
    	/*
	<summary>
	通过主键定位记录，没有则插入，有则更新
	</summary>
	<param name="rData">记录的类对象</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _Save_(const CDBDemo& rData, DWORD dwFlag = 0) const;
	
	/*
	<summary>
	用Update进行插入或者更新多个记录
	</summary>
	<param name="rData">记录的类向量对象</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _Save_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;
	
	/*
	<summary>
	用UpdateBatch进行批量插入或者更新多个记录
	</summary>
	<param name="rData">记录的类向量对象</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _SaveBatch_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;

    D.插入

    [cpp] view plain copy print ?
    1. /* 
    2. <summary> 
    3. 用Update进行插入单个记录 
    4. </summary> 
    5. <param name="rData">记录的类对象</param> 
    6. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    7. <returns>是否执行成功</returns> 
    8. */  
    9. bool _Insert_(const CDBDemo& rData, DWORD dwFlag = 0) const;  
    10.   
    11. /* 
    12. <summary> 
    13. 用Update进行插入多个记录 
    14. </summary> 
    15. <param name="rData">记录的类向量对象</param> 
    16. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    17. <returns>是否执行成功</returns> 
    18. */  
    19. bool _Insert_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;  
    20.   
    21. /* 
    22. <summary> 
    23. 用UpdateBatch进行批量插入多个记录 
    24. </summary> 
    25. <param name="rData">记录的类向量对象</param> 
    26. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    27. <returns>是否执行成功</returns> 
    28. */  
    29. bool _InsertBatch_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;  
    	/*
	<summary>
	用Update进行插入单个记录
	</summary>
	<param name="rData">记录的类对象</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _Insert_(const CDBDemo& rData, DWORD dwFlag = 0) const;
	
	/*
	<summary>
	用Update进行插入多个记录
	</summary>
	<param name="rData">记录的类向量对象</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _Insert_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;
	
	/*
	<summary>
	用UpdateBatch进行批量插入多个记录
	</summary>
	<param name="rData">记录的类向量对象</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _InsertBatch_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;

    E.更新

    [cpp] view plain copy print ?
    1. /* 
    2. <summary> 
    3. 用Update进行更新单个记录 
    4. </summary> 
    5. <param name="rData">记录的类对象</param> 
    6. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    7. <returns>是否执行成功</returns> 
    8. */  
    9. bool _Update_(const CDBDemo& rData, DWORD dwFlag = 0) const;  
    10.   
    11. /* 
    12. <summary> 
    13. 用Update进行更新多个记录，确保记录集与类向量对象个数及顺序一致性，否则会发生更新错乱 
    14. </summary> 
    15. <param name="rData">记录的类向量对象</param> 
    16. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    17. <returns>是否执行成功</returns> 
    18. */  
    19. bool _Update_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;  
    20.   
    21. /* 
    22. <summary> 
    23. 用UpdateBatch进行批量更新多个记录，确保记录集与类向量对象个数及顺序一致性，否则会发生更新错乱 
    24. </summary> 
    25. <param name="rData">记录的类向量对象</param> 
    26. <param name="dwFlag">用来控制类对象参与操作的字段</param> 
    27. <returns>是否执行成功</returns> 
    28. */  
    29. bool _UpdateBatch_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;  
    	/*
	<summary>
	用Update进行更新单个记录
	</summary>
	<param name="rData">记录的类对象</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _Update_(const CDBDemo& rData, DWORD dwFlag = 0) const;
	
	/*
	<summary>
	用Update进行更新多个记录，确保记录集与类向量对象个数及顺序一致性，否则会发生更新错乱
	</summary>
	<param name="rData">记录的类向量对象</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _Update_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;
	
	/*
	<summary>
	用UpdateBatch进行批量更新多个记录，确保记录集与类向量对象个数及顺序一致性，否则会发生更新错乱
	</summary>
	<param name="rData">记录的类向量对象</param>
	<param name="dwFlag">用来控制类对象参与操作的字段</param>
	<returns>是否执行成功</returns>
	*/
	bool _UpdateBatch_(const std::vector<CDBDemo>& rData, DWORD dwFlag = 0) const;

    F.删除

    [cpp] view plain copy print ?
    1. /* 
    2. <summary> 
    3. 通过主键定位，删除单个记录 
    4. </summary> 
    5. <param name="rData">记录的类对象</param> 
    6. <returns>是否执行成功</returns> 
    7. */  
    8. bool _Delete_(const CDBDemo& rData) const;  
    9.   
    10. /* 
    11. <summary> 
    12. 删除多个记录 
    13. </summary> 
    14. <param name="rData">记录的类向量对象</param> 
    15. <returns>是否执行成功</returns> 
    16. */  
    17. bool _Delete_(const std::vector<CDBDemo>& rData) const;  
    18.   
    19. /* 
    20. <summary> 
    21. 删除表记录 
    22. </summary> 
    23. <param name="lpszWhere">SQL语句的WHERE子句</param> 
    24. <returns>是否执行成功</returns> 
    25. */  
    26. bool _DeleteCDBDemo_(LPCTSTR lpszWhere= _T("")) const;  
    	/*
	<summary>
	通过主键定位，删除单个记录
	</summary>
	<param name="rData">记录的类对象</param>
	<returns>是否执行成功</returns>
	*/
	bool _Delete_(const CDBDemo& rData) const;
	
	/*
	<summary>
	删除多个记录
	</summary>
	<param name="rData">记录的类向量对象</param>
	<returns>是否执行成功</returns>
	*/
	bool _Delete_(const std::vector<CDBDemo>& rData) const;
	
	/*
	<summary>
	删除表记录
	</summary>
	<param name="lpszWhere">SQL语句的WHERE子句</param>
	<returns>是否执行成功</returns>
	*/
	bool _DeleteCDBDemo_(LPCTSTR lpszWhere= _T("")) const;

    以后每增加一个表只需要按上面的格式用ADO_DECLARE和ADO_IMPLEMENT增加相应的数据库增删查改操作。

    增加成员函数名修饰前缀和成员函数名修饰后缀作用是可以使得一个数据记录类可以对应多个表。


    6.在本例子中是建立一个长连接来做数据库操作

    在主对话框CADODemoDlg中头文件中用include添加了业务数据库的头文件DBBusiness.h，然后添加了CDBBusiness类型成员变量m_dbBusiness，故在程序初始化的时候连接用如下代码连接数据库

    [cpp] view plain copy print ?
    1. BOOL CADODemoDlg::DBInit(void)  
    2. {  
    3.     AfxOleInit();  
    4.     BOOL bRet =  m_dbBusiness.Connect();  
    5.     if (!bRet)  
    6.     {  
    7.         AfxMessageBox(m_dbBusiness.GetLastError());  
    8.     }  
    9.     return bRet;  
    10. }  
    BOOL CADODemoDlg::DBInit(void)
{
	AfxOleInit();
	BOOL bRet =  m_dbBusiness.Connect();
	if (!bRet)
	{
		AfxMessageBox(m_dbBusiness.GetLastError());
	}
	return bRet;
}


    注:有的数据库驱动程序可能无法提供Batch结尾的函数，比如SQL Server2005测试了需要连接之前将CursorLocation设置成adUseClient。

    至此，大部分数据封装操作代码都写完了，然后在你需要的地方调用ADO_DECLARE声明的函数即可，以上完成了大部分数据库增删改查代码的编写。

    把上面的连接ACCESS的连接字符串改成SQLSERVER2005的即可，表结构相同的话上面的数据库增删查改代码一样可以是通用（这个做不同数据库数据导入导出可就方便了)。

    [cpp] view plain copy print ?
    1. BOOL CDBBusiness::Connect(void)  
    2. {  
    3.     // 服务器：127.0.0.1 端口：1434   
    4.     // 用户名：sa  
    5.     // 密码：123456  
    6.     // 数据库：test  
    7.     strConnction = _T("Provider=SQLOLEDB;Server=127.0.0.1,1434;Database=test;User ID=sa;pwd=123456;");  
    8.     return Open(strConnction);  
    9. }  
    BOOL CDBBusiness::Connect(void)
{
	// 服务器：127.0.0.1 端口：1434 
	// 用户名：sa
	// 密码：123456
	// 数据库：test
	strConnction = _T("Provider=SQLOLEDB;Server=127.0.0.1,1434;Database=test;User ID=sa;pwd=123456;");
	return Open(strConnction);
}

    调用存储过程

    [sql] view plain copy print ?
    1. --SQL Server 2005 存储过程  
    2. Create Procedure [dbo].[usp_ProcedureTest]    
    3. @firstParam int,    
    4. @secondParam int Output,    
    5. @thirdParam datetime Output    
    6. As   
    7. BEGIN     
    8.     -- 返回记录集的话最好是用下面语句关闭一些不必要的返回记录集  
    9.     SET NOCOUNT ON;   
    10.   
    11.     DECLARE @Count int  
    12.     SET @secondParam = @firstParam * 10  
    13.     SELECT @thirdParam = getdate()   
    14.     SELECT @Count = Count(*) FROM tbl_Demo  
    15.     SELECT * FROM tbl_Demo  
    16.     return @Count   
    17. END  
    18. GO  
    --SQL Server 2005 存储过程
Create Procedure [dbo].[usp_ProcedureTest]  
@firstParam int,  
@secondParam int Output,  
@thirdParam datetime Output  
As 
BEGIN   
	-- 返回记录集的话最好是用下面语句关闭一些不必要的返回记录集
	SET NOCOUNT ON; 

	DECLARE @Count int
	SET @secondParam = @firstParam * 10
    SELECT @thirdParam = getdate() 
	SELECT @Count = Count(*) FROM tbl_Demo
	SELECT * FROM tbl_Demo
    return @Count 
END
GO

    调用代码：

    [cpp] view plain copy print ?
    1. CAdoCommand cmd(m_dbBusiness);  
    2. cmd.PutCommandText(_T("usp_ProcedureTest")); // 设置存储过程名称  
    3. long nFirstParam = 10;  
    4. cmd[_T("@firstParam")].PutValue(nFirstParam); // 设置输入参数值  
    5. CAdoRecordset rs;  
    6. if (cmd.Execute(rs)) //执行存储过程  
    7. {  
    8.     long nSecondParam = 0;  
    9.     cmd[_T("@secondParam")].GetValue(nSecondParam); // 获取output参数值  
    10.     SYSTEMTIME stThirdParam;  
    11.     cmd[_T("@thirdParam")].GetValue(stThirdParam);  // 获取output参数值  
    12.     std::vector<CDBDemo> lDBDemoRecord;  
    13.     CAdoDatabase::DBMultiSelectS(lDBDemoRecord, rs, 0, false); // 获取记录集  
    14.     rs.Close(); // 需要先关闭记录集才能获取返回值  
    15.     UINT nReturn;  
    16.     cmd[(long)0].GetValue(nReturn); // 获取返回值，用索引访问不能用int类型  
    17.     ASSERT(nReturn == lDBDemoRecord.size());  
    18.   
    19.     CString strMsg;  
    20.     strMsg.Format(_T("%d*10是%d\n记录集个数为%d\n数据库时间是%02d:%02d:%02d"),  
    21.         nFirstParam, nSecondParam, nReturn,  
    22.         stThirdParam.wHour, stThirdParam.wMinute, stThirdParam.wSecond);  
    23.     AfxMessageBox(strMsg);  
    24. }  
    25. else  
    26. {  
    27.     AfxMessageBox(m_dbBusiness.GetLastError());  
    28. }     
    	CAdoCommand cmd(m_dbBusiness);
	cmd.PutCommandText(_T("usp_ProcedureTest")); // 设置存储过程名称
	long nFirstParam = 10;
	cmd[_T("@firstParam")].PutValue(nFirstParam); // 设置输入参数值
	CAdoRecordset rs;
	if (cmd.Execute(rs)) //执行存储过程
	{
		long nSecondParam = 0;
		cmd[_T("@secondParam")].GetValue(nSecondParam); // 获取output参数值
		SYSTEMTIME stThirdParam;
		cmd[_T("@thirdParam")].GetValue(stThirdParam);  // 获取output参数值
		std::vector<CDBDemo> lDBDemoRecord;
		CAdoDatabase::DBMultiSelectS(lDBDemoRecord, rs, 0, false); // 获取记录集
		rs.Close(); // 需要先关闭记录集才能获取返回值
		UINT nReturn;
		cmd[(long)0].GetValue(nReturn); // 获取返回值，用索引访问不能用int类型
		ASSERT(nReturn == lDBDemoRecord.size());

		CString strMsg;
		strMsg.Format(_T("%d*10是%d\n记录集个数为%d\n数据库时间是%02d:%02d:%02d"),
			nFirstParam, nSecondParam, nReturn,
			stThirdParam.wHour, stThirdParam.wMinute, stThirdParam.wSecond);
		AfxMessageBox(strMsg);
	}
	else
	{
		AfxMessageBox(m_dbBusiness.GetLastError());
	}



    顶
    0
    踩
    0
    MFC之ADO数据库快速编程Demo-C++代码类资源
    09-08
    标题中的“MFC之ADO数据库快速编程Demo-C++代码类资源”表明这是一个使用Microsoft Foundation Class (MFC)库，通过ActiveX Data Objects (ADO)进行数据库操作的C++编程示例。MFC是微软提供的一个C++类库，用于简化...
    ADO数据库编程入门
    liandong的专栏
    06-16 1493
     ADO数据库编程入门 李安东编写2002年2月28日摘要  本文简要介绍了在VC++ 6.0中使用 ADO进行客户端数据库编程的基本步骤，以及常见问题的解决方法，可供入门级的参考之用。关键字  ADO  VC++   数据库编程ADO 是目前在Windows环境中比较流行的客户端数据库编程技术。ADO是建立在OLE DB底层技术之上的高级编程接口，因而它兼具有强大的数据处理功
    ADO数据库编程 - 总结
    weixin_30758821的博客
    05-15 228
    一、数据库操作准备 // --------------------------------------------------------------------------------------------------------------------------------- 1、导入ADO动态链接库 　　在工程的stdafx.h中加入如下语句： 　　#import "C...
    MFC 数据库编程 增删改查的一个例子
    易水寒
    07-25 3223
    1.先看下效果图： 主界面： 一个最简单的1对多的表，一张Article(文章)表，一张Category(类别)表。有添加，修改，删除文章按钮。点击类别编辑按钮就会跳到第二个对话框。点击数据库配置就会跳到第三个对话框。 类别编辑的对话框，类别做了防止重复数据添加的功能。 数据库配置的对话框，记录会保存到文件中。 2.保存数据
    VC++ ADO开发实践之一
    zswzwy的专栏
    09-17 2568
    ADO第一次亲密接触 -- ADO开发实践之一 一、ADO简介ADO(ActiveX Data Object)是Microsoft数据库应用程序开发的新接口，是建立在OLE DB之上的高层数据库访问技术，请不必为此担心，即使你对OLE DB，COM不了解也能轻松对付ADO,因为它非常简单易用，甚至比你以往所接触的ODBC API、DAO、RDO都要容易使用，并不失灵活性。本文将详细地介绍在VC下如
    MFC之ADO数据库快速编程Demo
    10-16
    本Demo主要展示了如何在MFC应用中利用ADO进行快速的数据库编程，涵盖了基本的数据库操作：增、删、改、查。 首先，使用ADO进行数据库操作，你需要包含必要的头文件，如`#include <afxdao.h>`，这包含了ADO的接口。...
    MFC_ADO.rar_MFC数据库编程_ado mfc
    09-19
    文件“MFC_ADO数据库编程参考1.txt”和“MFC_ADO数据库编程参考2.txt”可能包含了更具体的示例代码和最佳实践，建议仔细阅读以深入理解MFC_ADO数据库编程。 总之，MFC_ADO结合了MFC的强大功能和ADO的数据库访问能力...
    MFC实现ADO数据库编程技巧详解
    ### 标题知识点：精通MFC--ADO数据库编程 #### 1. MFC技术概述 MFC是Microsoft Foundation Classes的缩写，是微软公司提供的一套用于编写Windows应用程序的C++类库。它封装了Windows API（应用程序编程接口），并...
    ADO数据库编程
    梦想家-的博客
    11-03 297
    一下代码全部测试通过： 连接数据库代码如下： HRESULT hr; CoInitialize(NULL); CString strSQL; _variant_t user_name;      //HRESULT hr; try     {             hr=m_pConnection.CreateInstance(__uuidof(Connection));
    ADO数据库编程ADO数据库编程
    06-19
    ADO数据库编程ADO数据库编程ADO数据库编程ADO数据库编程
    MFC ADO数据库编程分解实例
    04-30
    这资源专门针对菜鸟，自己也曾在网上实例很乱，在花费了很多时间精力的情况下找到了不错的资源，该资源只要是将数据库的增删查改资源分解；在此与大家分享，对于菜鸟而言很难一步步实现增删查改功能；
    基于MFC的数据库编程
    12-27
    基于MFC的数据库编程，连接Access数据库，简单的数据库连接代码，适合初学者学习使用
    MFC数据库编程_C++_vc++_MFC_
    10-01
    数据库技术作为计算机应用领域的重要组成部分，已经渗透到社会生活的方方面面。
    MFC 数据库编程 自己整理的
    03-09
    MFC的数据库编程，自己整理的几种方法！
    使用MFC ODBC +SQL Server2005 实现数据库编程
    MoaKap的专栏
    09-20 7150
    最近在项目中添加了用户数据管理功能，使用MFC ODBC连接SQL Server2005数据库。由于以前没有接触过数据库具体的实现，因此花了两周时间学习了数据库的知识，并实现了项目中的基本功能。感觉虽然存在很多问题，但还是有不少收获。下面总结一下，希望能够给跟我一样的新手们一个参考，大家共同学习！要在应用中实现一个基本的数据库系统，除了要有数据库，还要将自己的程序与数据库之间建立连接，在程序中
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

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

    抵扣说明：

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

    余额充值