C++博客-Welcome to tiger's blog!

const用法

tiger — Fri, 12 Sep 2014 11:41:00 GMT

#include using namespace std; /* * const由编译器决定 * 指针运算符*，是从右到左，那么如：char const * pContent，可以理解为char const (* pContent)，即* pContent为const，而pContent则是可变的。 */ int main(int argc, char *argv[]) { int nData = 1; //情形1: const修饰a1/a2, 以下两种情形等同 const int a1 = 1; // a1 = 2; //a1为常量，编译报错 int const a2 = 1; // a2 = 2; //a2为常量，编译报错 ///////////////////////////////////// //情形2: const修饰(*p1)/(*p2), 以下两种情形等同 const int *p1 = &nData; // *p1 = 2; //*p1为常量，编译报错 p1++; //p1指针为非常量，野指针，但编译通过 cout<<"*p1 == "<<*p1<

tiger 2014-09-12 19:41 发表评论

无名非阻塞管道

tiger — Sat, 04 Sep 2010 03:14:00 GMT

int fd[2];
int nPipeReadFlag = 0;
fd[0] = -1;
fd[2] = -1;

if ((-1 == pipe(fd)) || (-1 == fd[0]) || (-1 == fd[1]))
{
  SK_ERROR(("Create pipe failed!"));
  return;
}

//以下代码设置读管道为非阻塞。设置写管道等类似，其他读写代码等一样
nPipeReadFlag = fcntl(fd[0], F_GETFL, 0);
nPipeReadFlag |= O_NONBLOCK;
if (fcntl(fd[0], F_SETFL, nPipeReadFlag) < 0)
{
  SK_ERROR(("set read pipe flaf failed!"));
  return;
}

tiger 2010-09-04 11:14 发表评论

NAND Flash--嵌入式NAND Flash读写技术

tiger — Mon, 17 May 2010 09:37:00 GMT

NAND Flash--嵌入式NAND Flash读写技术

NAND Flash控制器

S3C2410板的Nand Flash支持由两部分组成:Nand Flash控制器(集成在S3C2410 CPU)和Nand Flash存储芯片(K9F1208U0B)两部分组成。当要访问Nand Flash中的数据时,必须通过Nand Flash控制器发送命令才能完成。所以Nand Flash相当于S3C2410的一个外设,而不位于它的内存地址区.

为了支持NAND Flash的启动装载，S3C2410A配置了一个叫Steppingstone的内部SRAM缓冲器。当系统启动时，NAND Flash存储器的前4KB将被自动加载到Steppingstone中，然后系统自动执行这些载入的启动代码。

一般情况下，这4KB的启动代码需要将NAND Flash中的内容复制到SDRAM中。使用S3C2410A内部硬件ECC功能可以对NAND Flash的数据进行有效性的检查。复制完成后，将在SDRAM中执行主程序。

NAND Flash控制其具有以下特性：

* NAND Flash模式：支持读/擦除/编程NAND Flash存储器。

* 自动启动模式：复位后，启动代码被传送到Steppingstone中。传送完毕后，启动代码在Steppingstone中执行。

* 具备硬件ECC（校验码：Error Correction Code）生成模块（硬件生成校验码，通过软件校验）

* NAND Flash启动以后，4KB的内部SRAM缓冲器Steppingstone可以作为其他用途使用。

* NAND Flash控制器不能通过DMA访问，可以使用LDM/STM指令来代替DMA操作。

自启动模式的执行步骤如下：

（1）完成复位

（2）如果自动启动模式使能，NAND Flash存储器的前4KB自动复制到Steppingstone内部缓冲器；

（3）Steppingstone映射到nGCS0；

（4）CPU在Steppingstone的4KB内部缓冲器中开始执行启动代码。

注意：在自动启动模式下，不进行ECC检测。因此，应确保NAND Flash的前4KB不能有位错误（一般NAND Flash厂家都能确保）。

NAND Flash模式需要进行以下配置：

（1）通过NFCONF寄存器设置NAND Flash配置；

（2）将NAND Flash命令写入NFCONF寄存器；

（3）将NAND Flash地址写入NFADDR寄存器；

（4）通过NFSTAT寄存器检查NAND Flash状态，并读/写数据。在读操作之前或者编程操作之后应该检查R/nB信号。

引脚配置

D[7：0] 数据/命令/地址的输入/输出口（与数据总线共享）

CLE 命令锁存使能（输出）

ALE 地址锁存使能（输出）

nFCE NAND Flash片选使能（输出）

nFRE NAND Flash读使能（输出）

nFWE NAND Flash写使能（输出）

R/nB NAND Flash就绪/忙（输入）

系统启动和NAND Flash所需的配置如下：

（1）OM[1：0]=00b：使能NAND Flash控制器为自动启动模式；

（2）NAND Flash存储器的页面大小应该为512字节；

（3）NCON：NAND Flash存储器寻址步数选择。0为3步；1为4步寻址。

Linux MTD 源代码

tiger — Tue, 11 May 2010 02:16:00 GMT

摘要: Linux MTD 源代码目录专有名词：.... 7 Linux MTD介绍：... 8 设备层和原始设备层的函数调用关系（红色部分需要我们实现）：... 9 NOR型Flash芯片驱动与MTD原始设备... 10 NAND和NOR的比较... 11 源码分析... 14 头文件分析... 14 mtd.h. 14 MTD_CHAR_MAJOR. 14 ... 阅读全文

tiger 2010-05-11 10:16 发表评论

字符编码方式介绍

tiger — Thu, 12 Nov 2009 08:23:00 GMT

1. ASCII码

我们知道，在计算机内部，所有的信息最终都表示为一个二进制的字符串。每一个二进制位（bit）有0和1两种状态，因此八个二进制位就可以组合出256种状态，这被称为一个字节（byte）。也就是说，一个字节一共可以用来表示256种不同的状态，每一个状态对应一个符号，就是256个符号，从0000000到11111111。

上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASCII码，一直沿用至今。

ASCII码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）。这128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。

2、非ASCII编码

英语用128个符号编码就够了，但是用来表示其他语言，128个符号是不够的。比如，在法语中，字母上方有注音符号，它就无法用ASCII码表示。于是，一些欧洲国家就决定，利用字节中闲置的最高位编入新的符号。比如，法语中的é的编码为130（二进制10000010）。这样一来，这些欧洲国家使用的编码体系，可以表示最多256个符号。

但是，这里又出现了新的问题。不同的国家有不同的字母，因此，哪怕它们都使用256个符号的编码方式，代表的字母却不一样。比如，130在法语编码中代表了é，在希伯来语编码中却代表了字母Gimel (ג)，在俄语编码中又会代表另一个符号。但是不管怎样，所有这些编码方式中，0—127表示的符号是一样的，不一样的只是128—255的这一段。

至于亚洲国家的文字，使用的符号就更多了，汉字就多达10万左右。一个字节只能表示256种符号，肯定是不够的，就必须使用多个字节表达一个符号。比如，简体中文常见的编码方式是GB2312，使用两个字节表示一个汉字，所以理论上最多可以表示256x256=65536个符号。

中文编码的问题需要专文讨论，这篇笔记不涉及。这里只指出，虽然都是用多个字节表示一个符号，但是GB类的汉字编码与后文的Unicode和UTF-8是毫无关系的。

3.Unicode

正如上一节所说，世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读，就会出现乱码。为什么电子邮件常常出现乱码？就是因为发信人和收信人使用的编码方式不一样。

可以想象，如果有一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，那么乱码问题就会消失。这就是Unicode，就像它的名字都表示的，这是一种所有符号的编码。

Unicode当然是一个很大的集合，现在的规模可以容纳100多万个符号。每个符号的编码都不一样，比如，U+0639表示阿拉伯字母Ain，U+0041表示英语的大写字母A，U+4E25表示汉字“严”。具体的符号对应表，可以查询unicode.org，或者专门的汉字对应表。

4. Unicode的问题

需要注意的是，Unicode只是一个符号集，它只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储。

比如，汉字“严”的unicode是十六进制数4E25，转换成二进制数足足有15位（100111000100101），也就是说这个符号的表示至少需要2个字节。表示其他更大的符号，可能需要3个字节或者4个字节，甚至更多。

这里就有两个严重的问题，第一个问题是，如何才能区别unicode和ascii？计算机怎么知道三个字节表示一个符号，而不是分别表示三个符号呢？第二个问题是，我们已经知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是0，这对于存储来说是极大的浪费，文本文件的大小会因此大出二三倍，这是无法接受的。

它们造成的结果是：1）出现了unicode的多种存储方式，也就是说有许多种不同的二进制格式，可以用来表示unicode。2）unicode在很长一段时间内无法推广，直到互联网的出现。

5.UTF-8

互联网的普及，强烈要求出现一种统一的编码方式。UTF-8就是在互联网上使用最广的一种unicode的实现方式。其他实现方式还包括UTF-16和UTF-32，不过在互联网上基本不用。重复一遍，这里的关系是，UTF-8是Unicode的实现方式之一。

UTF-8最大的一个特点，就是它是一种变长的编码方式。它可以使用1~4个字节表示一个符号，根据不同的符号而变化字节长度。

UTF-8的编码规则很简单，只有二条：

1）对于单字节的符号，字节的第一位设为0，后面7位为这个符号的unicode码。因此对于英语字母，UTF-8编码和ASCII码是相同的。

2）对于n字节的符号（n>1），第一个字节的前n位都设为1，第n+1位设为0，后面字节的前两位一律设为10。剩下的没有提及的二进制位，全部为这个符号的unicode码。

下表总结了编码规则，字母x表示可用编码的位。

Unicode符号范围 | UTF-8编码方式
(十六进制) | （二进制）
--------------------+---------------------------------------------
0000 0000-0000 007F | 0xxxxxxx
0000 0080-0000 07FF | 110xxxxx 10xxxxxx
0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

下面，还是以汉字“严”为例，演示如何实现UTF-8编码。

已知“严”的unicode是4E25（100111000100101），根据上表，可以发现4E25处在第三行的范围内（0000 0800-0000 FFFF），因此“严”的UTF-8编码需要三个字节，即格式是“1110xxxx 10xxxxxx 10xxxxxx”。然后，从“严”的最后一个二进制位开始，依次从后向前填入格式中的x，多出的位补0。这样就得到了，“严”的UTF-8编码是“11100100 10111000 10100101”，转换成十六进制就是E4B8A5。

6. Unicode与UTF-8之间的转换

通过上一节的例子，可以看到“严”的Unicode码是4E25，UTF-8编码是E4B8A5，两者是不一样的。它们之间的转换可以通过程序实现。

在Windows平台下，有一个最简单的转化方法，就是使用内置的记事本小程序Notepad.exe。打开文件后，点击“文件”菜单中的“另存为”命令，会跳出一个对话框，在最底部有一个“编码”的下拉条。

里面有四个选项：ANSI，Unicode，Unicode big endian 和 UTF-8。

1）ANSI是默认的编码方式。对于英文文件是ASCII编码，对于简体中文文件是GB2312编码（只针对Windows简体中文版，如果是繁体中文版会采用Big5码）。

2）Unicode编码指的是UCS-2编码方式，即直接用两个字节存入字符的Unicode码。这个选项用的little endian格式。

3）Unicode big endian编码与上一个选项相对应。我在下一节会解释little endian和big endian的涵义。

4）UTF-8编码，也就是上一节谈到的编码方法。

选择完”编码方式“后，点击”保存“按钮，文件的编码方式就立刻转换好了。

7. Little endian和Big endian

上一节已经提到，Unicode码可以采用UCS-2格式直接存储。以汉字”严“为例，Unicode码是4E25，需要用两个字节存储，一个字节是4E，另一个字节是25。存储的时候，4E在前，25在后，就是Big endian方式；25在前，4E在后，就是Little endian方式。

这两个古怪的名称来自英国作家斯威夫特的《格列佛游记》。在该书中，小人国里爆发了内战，战争起因是人们争论，吃鸡蛋时究竟是从大头(Big-Endian)敲开还是从小头(Little-Endian)敲开。为了这件事情，前后爆发了六次战争，一个皇帝送了命，另一个皇帝丢了王位。

因此，第一个字节在前，就是”大头方式“（Big endian），第二个字节在前就是”小头方式“（Little endian）。

那么很自然的，就会出现一个问题：计算机怎么知道某一个文件到底采用哪一种方式编码？

Unicode规范中定义，每一个文件的最前面分别加入一个表示编码顺序的字符，这个字符的名字叫做”零宽度非换行空格“（ZERO WIDTH NO-BREAK SPACE），用FEFF表示。这正好是两个字节，而且FF比FE大1。

如果一个文本文件的头两个字节是FE FF，就表示该文件采用大头方式；如果头两个字节是FF FE，就表示该文件采用小头方式。

8. 实例

下面，举一个实例。

打开”记事本“程序Notepad.exe，新建一个文本文件，内容就是一个”严“字，依次采用ANSI，Unicode，Unicode big endian 和 UTF-8编码方式保存。

然后，用文本编辑软件UltraEdit中的”十六进制功能“，观察该文件的内部编码方式。

1）ANSI：文件的编码就是两个字节“D1 CF”，这正是“严”的GB2312编码，这也暗示GB2312是采用大头方式存储的。

2）Unicode：编码是四个字节“FF FE 25 4E”，其中“FF FE”表明是小头方式存储，真正的编码是4E25。

3）Unicode big endian：编码是四个字节“FE FF 4E 25”，其中“FE FF”表明是大头方式存储。

4）UTF-8：编码是六个字节“EF BB BF E4 B8 A5”，前三个字节“EF BB BF”表示这是UTF-8编码，后三个“E4B8A5”就是“严”的具体编码，它的存储顺序与编码顺序是一致的。

tiger 2009-11-12 16:23 发表评论

设计模式(Singleton)

tiger — Mon, 16 Apr 2007 02:57:00 GMT

#include
using namespace std;

class CSingleton
{
private:
CSingleton();

public:
virtual ~CSingleton();

public:
static CSingleton *GetInstance();

private:
static CSingleton *s_pSingleton;

};

CSingleton *CSingleton::s_pSingleton = NULL;

CSingleton::CSingleton()
{
}

CSingleton::~CSingleton()
{
if(CSingleton::s_pSingleton != NULL)
{
delete CSingleton::s_pSingleton;
CSingleton::s_pSingleton = NULL;
}
}

CSingleton *CSingleton::GetInstance()
{
if(CSingleton::s_pSingleton == NULL)
{
CSingleton::s_pSingleton = new CSingleton();
}

return CSingleton::s_pSingleton;
}

void main()
{
for(int i = 0; i < 10; i++)
{
CSingleton *pSingleton = CSingleton::GetInstance();
cout< }
}

tiger 2007-04-16 10:57 发表评论

设计模式(Decorator)

tiger — Sat, 14 Apr 2007 07:06:00 GMT

// Component.h: interface for the CComponent class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_COMPONENT_H__9FC0172F_E325_422F_82D4_719D1E4DB8A6__INCLUDED_)
#define AFX_COMPONENT_H__9FC0172F_E325_422F_82D4_719D1E4DB8A6__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include
using namespace std;

class CComponent
{
public:
CComponent();
virtual ~CComponent();

public:
virtual void Func(void) = 0;

};

#endif // !defined(AFX_COMPONENT_H__9FC0172F_E325_422F_82D4_719D1E4DB8A6__INCLUDED_)

// Component.cpp: implementation of the CComponent class.
//
//////////////////////////////////////////////////////////////////////

#include "Component.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CComponent::CComponent()
{

}

CComponent::~CComponent()
{

}

// Decorator.h: interface for the CDecorator class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_DECORATOR_H__D1305BFE_4F87_4D1F_A661_8496D9C28CFE__INCLUDED_)
#define AFX_DECORATOR_H__D1305BFE_4F87_4D1F_A661_8496D9C28CFE__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "Component.h"

class CDecorator : public CComponent
{
public:
CDecorator(CComponent *pComponent);
virtual ~CDecorator();

protected:
CComponent *m_pComponent;

};

class CConcreteDecorator : public CDecorator
{
public:
CConcreteDecorator(CComponent *pComponent);
virtual ~CConcreteDecorator();

public:
void Func(void);

private:
void AdditionFunc(void);
};

#endif // !defined(AFX_DECORATOR_H__D1305BFE_4F87_4D1F_A661_8496D9C28CFE__INCLUDED_)

// Decorator.cpp: implementation of the CDecorator class.
//
//////////////////////////////////////////////////////////////////////

#include "Decorator.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CDecorator::CDecorator(CComponent *pComponent)
{
m_pComponent = pComponent;
}

CDecorator::~CDecorator()
{

}

//////////////////////////////////////////////////////////////////////
CConcreteDecorator::CConcreteDecorator(CComponent *pComponent)
: CDecorator(pComponent)
{
}

CConcreteDecorator::~CConcreteDecorator()
{
}

void CConcreteDecorator::Func()
{
m_pComponent->Func();
AdditionFunc();
}

void CConcreteDecorator::AdditionFunc()
{
cout<<"CConcreteDecorator::AdditionFunc"<}
//////////////////////////////////////////////////////////////////////

//main.cpp
#include "ConcreteComponent.h"
#include "Decorator.h"

void main()
{
CComponent *pComponent = new CConcreteComponent();
CComponent *pDecorator = new CConcreteDecorator(pComponent);
pDecorator->Func();
delete pDecorator;
delete pComponent;
}

tiger 2007-04-14 15:06 发表评论

设计模式(Strategy)

tiger — Sat, 14 Apr 2007 07:04:00 GMT

// Strategy.h: interface for the CStrategy class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_STRATEGY_H__174A97DA_5D7A_4183_8361_4B6471820E62__INCLUDED_)
#define AFX_STRATEGY_H__174A97DA_5D7A_4183_8361_4B6471820E62__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CStrategy
{
public:
CStrategy();
virtual ~CStrategy();

public:
virtual void AlgrithmInterface(void) = 0;

};

class CConcreteStrategyA : public CStrategy
{
public:
CConcreteStrategyA();
virtual ~CConcreteStrategyA();

public:
void AlgrithmInterface(void);
};

class CConcreteStrategyB : public CStrategy
{
public:
CConcreteStrategyB();
virtual ~CConcreteStrategyB();

public:
void AlgrithmInterface(void);
};

#endif // !defined(AFX_STRATEGY_H__174A97DA_5D7A_4183_8361_4B6471820E62__INCLUDED_)

// Strategy.cpp: implementation of the CStrategy class.
//
//////////////////////////////////////////////////////////////////////

#include "Strategy.h"

#include
using namespace std;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CStrategy::CStrategy()
{

}

CStrategy::~CStrategy()
{

}

//////////////////////////////////////////////////////////////////////
CConcreteStrategyA::CConcreteStrategyA()
{

}

CConcreteStrategyA::~CConcreteStrategyA()
{

}

void CConcreteStrategyA::AlgrithmInterface()
{
cout<<"CConcreteStrategyA::AlgrithmInterface"<}
//////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////
CConcreteStrategyB::CConcreteStrategyB()
{

}

CConcreteStrategyB::~CConcreteStrategyB()
{

}

void CConcreteStrategyB::AlgrithmInterface()
{
cout<<"CConcreteStrategyB::AlgrithmInterface"<}
//////////////////////////////////////////////////////////////////////

// Context.h: interface for the CContext class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_CONTEXT_H__E299AB56_F88B_4134_83B5_DF6A5AFCADE4__INCLUDED_)
#define AFX_CONTEXT_H__E299AB56_F88B_4134_83B5_DF6A5AFCADE4__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CStrategy;

class CContext
{
public:
CContext(CStrategy *pStrategy);
virtual ~CContext();

public:
void DoAction(void);

private:
CStrategy *m_pStrategy;

};

#endif // !defined(AFX_CONTEXT_H__E299AB56_F88B_4134_83B5_DF6A5AFCADE4__INCLUDED_)

// Context.cpp: implementation of the CContext class.
//
//////////////////////////////////////////////////////////////////////

#include "Context.h"
#include "Strategy.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CContext::CContext(CStrategy *pStrategy)
{
m_pStrategy = pStrategy;
}

CContext::~CContext()
{

}

void CContext::DoAction()
{
m_pStrategy->AlgrithmInterface();
}

//main.cpp
#include "Strategy.h"
#include "Context.h"

void main()
{
CStrategy *pStrategy = new CConcreteStrategyB();
CContext *pContext = new CContext(pStrategy);
pContext->DoAction();
delete pContext;
delete pStrategy;
}

tiger 2007-04-14 15:04 发表评论

设计模式(Abstract Factory)

tiger — Fri, 13 Apr 2007 01:52:00 GMT

// Factory.h: interface for the CFactory class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_FACTORY_H__EA4BC919_0C3C_445D_95D0_0B3BC1A79A46__INCLUDED_)
#define AFX_FACTORY_H__EA4BC919_0C3C_445D_95D0_0B3BC1A79A46__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CProduct;

class CFactory
{
public:
CFactory();
virtual ~CFactory();

public:
virtual CProduct *CreateA(void) = 0;
virtual CProduct *CreateB(void) = 0;

};

class CFactory1 : public CFactory
{
public:
CFactory1();
virtual ~CFactory1();

public:
CProduct *CreateA(void);
CProduct *CreateB(void);

};

class CFactory2 : public CFactory
{
public:
CFactory2();
virtual ~CFactory2();

public:
CProduct *CreateA(void);
CProduct *CreateB(void);

};

#endif // !defined(AFX_FACTORY_H__EA4BC919_0C3C_445D_95D0_0B3BC1A79A46__INCLUDED_)

// Factory.cpp: implementation of the CFactory class.
//
//////////////////////////////////////////////////////////////////////

#include "Factory.h"

#include "Product.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CFactory::CFactory()
{

}

CFactory::~CFactory()
{

}

/////////////////////////////////////////////
CFactory1::CFactory1()
{

}

CFactory1::~CFactory1()
{

}

CProduct *CFactory1::CreateA()
{
return new CProductA1();
}

CProduct *CFactory1::CreateB()
{
return new CProductB1();
}
/////////////////////////////////////////////

/////////////////////////////////////////////
CFactory2::CFactory2()
{

}

CFactory2::~CFactory2()
{

}

CProduct *CFactory2::CreateA()
{
return new CProductA2();
}

CProduct *CFactory2::CreateB()
{
return new CProductB2();
}
/////////////////////////////////////////////

// Product.h: interface for the CProduct class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_PRODUCT_H__2A9147E1_2856_4F8A_9AD3_3BC7D3FD97E3__INCLUDED_)
#define AFX_PRODUCT_H__2A9147E1_2856_4F8A_9AD3_3BC7D3FD97E3__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CProduct
{
public:
CProduct();
virtual ~CProduct();

public:
virtual void Show(void) = 0;

};

class CProductA1 : public CProduct
{
public:
CProductA1();
virtual ~CProductA1();

public:
void Show(void);

};

class CProductB1 : public CProduct
{
public:
CProductB1();
virtual ~CProductB1();

public:
void Show(void);

};

class CProductA2 : public CProduct
{
public:
CProductA2();
virtual ~CProductA2();

public:
void Show(void);

};

class CProductB2 : public CProduct
{
public:
CProductB2();
virtual ~CProductB2();

public:
void Show(void);

};

#endif // !defined(AFX_PRODUCT_H__2A9147E1_2856_4F8A_9AD3_3BC7D3FD97E3__INCLUDED_)

// Product.cpp: implementation of the CProduct class.
//
//////////////////////////////////////////////////////////////////////

#include "Product.h"
#include
using namespace std;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CProduct::CProduct()
{

}

CProduct::~CProduct()
{

}

/////////////////////////////////////////////////////////
CProductA1::CProductA1()
{

}

CProductA1::~CProductA1()
{

}

void CProductA1::Show()
{
cout<<"CProductA1::Show"<}
/////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////
CProductB1::CProductB1()
{

}

CProductB1::~CProductB1()
{

}

void CProductB1::Show()
{
cout<<"CProductB1::Show"<}
/////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////
CProductA2::CProductA2()
{

}

CProductA2::~CProductA2()
{

}

void CProductA2::Show()
{
cout<<"CProductA2::Show"<}
/////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////
CProductB2::CProductB2()
{

}

CProductB2::~CProductB2()
{

}

void CProductB2::Show()
{
cout<<"CProductB2::Show"<}
/////////////////////////////////////////////////////////

//main
#include "Factory.h"
#include "Product.h"

#define NULL 0

void main()
{
CFactory *pFactory = NULL;
CProduct *pProductA = NULL;
CProduct *pProductB = NULL;

for(int i = 0; i < 2; i++)
{
  if(i == 0)
  {
   pFactory = new CFactory1();
  }
  else
  {
   pFactory = new CFactory2();
  }

  pProductA = pFactory->CreateA();
  pProductB = pFactory->CreateB();
  pProductA->Show();
  pProductB->Show();
  delete pFactory;
  delete pProductA;
  delete pProductB;
}
}

tiger 2007-04-13 09:52 发表评论

设计模式(Bridge)

tiger — Fri, 13 Apr 2007 01:49:00 GMT

// Abstraction.h: interface for the CAbstraction class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_ABSTRACTION_H__EEDB1B76_5760_4067_A2CB_95604AE082E4__INCLUDED_)
#define AFX_ABSTRACTION_H__EEDB1B76_5760_4067_A2CB_95604AE082E4__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CAbstractionImp;

class CAbstraction
{
public:
CAbstraction(CAbstractionImp *pAbstrationImp);
virtual ~CAbstraction();

protected:
CAbstraction();

public:
virtual void Func(void) = 0;

protected:
CAbstractionImp *m_pAbstractionImp;

};

class CRefindedAbstraction : public CAbstraction
{
public:
CRefindedAbstraction(CAbstractionImp *pAbstrationImp);
virtual ~CRefindedAbstraction();

public:
void Func(void);

};

#endif // !defined(AFX_ABSTRACTION_H__EEDB1B76_5760_4067_A2CB_95604AE082E4__INCLUDED_)

// Abstraction.cpp: implementation of the CAbstraction class.
//
//////////////////////////////////////////////////////////////////////

#include "Abstraction.h"

#include "AbstractionImp.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CAbstraction::CAbstraction()
{

}

CAbstraction::CAbstraction(CAbstractionImp *pAbstractionImp)
{
m_pAbstractionImp = pAbstractionImp;
}

CAbstraction::~CAbstraction()
{

}

/////////////////////////////////////////////////////////
CRefindedAbstraction::CRefindedAbstraction(CAbstractionImp *pAbstractionImp)
: CAbstraction(pAbstractionImp)
{

}

CRefindedAbstraction::~CRefindedAbstraction()
{

}

void CRefindedAbstraction::Func()
{
m_pAbstractionImp->Func();
}

// AbstractionImp.h: interface for the CAbstractionImp class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_ABSTRACTIONIMP_H__29762645_3054_47C4_BF33_D8DACB518CD5__INCLUDED_)
#define AFX_ABSTRACTIONIMP_H__29762645_3054_47C4_BF33_D8DACB518CD5__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CAbstractionImp
{
public:
CAbstractionImp();
virtual ~CAbstractionImp();

public:
virtual void Func(void) = 0;

};

class CAbstractionImpA : public CAbstractionImp
{
public:
CAbstractionImpA();
virtual ~CAbstractionImpA();

public:
void Func(void);

};

class CAbstractionImpB : public CAbstractionImp
{
public:
CAbstractionImpB();
virtual ~CAbstractionImpB();

public:
void Func(void);

};

#endif // !defined(AFX_ABSTRACTIONIMP_H__29762645_3054_47C4_BF33_D8DACB518CD5__INCLUDED_)

// AbstractionImp.cpp: implementation of the CAbstractionImp class.
//
//////////////////////////////////////////////////////////////////////

#include "AbstractionImp.h"
#include
using namespace std;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CAbstractionImp::CAbstractionImp()
{

}

CAbstractionImp::~CAbstractionImp()
{

}

/////////////////////////////////////////////
CAbstractionImpA::CAbstractionImpA()
{

}

CAbstractionImpA::~CAbstractionImpA()
{

}

void CAbstractionImpA::Func()
{
cout<<"CAbstractionImpA::Func"<}

/////////////////////////////////////////////
CAbstractionImpB::CAbstractionImpB()
{

}

CAbstractionImpB::~CAbstractionImpB()
{

}

void CAbstractionImpB::Func()
{
cout<<"CAbstractionImpB::Func"<}

//main
#include "Abstraction.h"
#include "AbstractionImp.h"

void main()
{
CAbstractionImp *pAbstractionImp = new CAbstractionImpB();
CAbstraction *pAbstraction = new CRefindedAbstraction(pAbstractionImp);
pAbstraction->Func();
delete pAbstraction;
delete pAbstractionImp;
}

tiger 2007-04-13 09:49 发表评论

设计模式(Adapter)

tiger — Fri, 13 Apr 2007 01:47:00 GMT

//类Adapter
#include
using namespace std;

class CAdaptee
{
public:
CAdaptee(){}
virtual ~CAdaptee(){}

public:
void Func1(){cout<<"CAdaptee"<

};

class CTarget
{
public:
CTarget(){}
virtual ~CTarget(){}

public:
virtual void Func() = 0;

};

class CAdapter : public CTarget, private CAdaptee
{
public:
CAdapter(){}
virtual ~CAdapter(){}

public:
void Func(){Func1();}

};

void main()
{
CTarget *pTarget = new CAdapter();
pTarget->Func();
delete pTarget;
}

//对象Adapter(组合)
#include
using namespace std;

class CAdaptee
{
public:
CAdaptee(){}
virtual ~CAdaptee(){}

public:
void Func1(){cout<<"CAdaptee"<

};

class CTarget
{
public:
CTarget(){}
virtual ~CTarget(){}

public:
virtual void Func() = 0;

};

class CAdapter : public CTarget
{
public:
CAdapter(){}
virtual ~CAdapter(){}

public:
void Func(){m_Adaptee.Func1();}

private:
CAdaptee m_Adaptee;

};

void main()
{
CTarget *pTarget = new CAdapter();
pTarget->Func();
delete pTarget;
}

//对象Adapter(参数)
#include
using namespace std;

class CAdaptee
{
public:
CAdaptee(){}
virtual ~CAdaptee(){}

public:
void Func1(){cout<<"CAdaptee"<

};

class CTarget
{
public:
CTarget(){}
virtual ~CTarget(){}

public:
virtual void Func() = 0;

};

class CAdapter : public CTarget
{
public:
CAdapter(CAdaptee *pAdaptee){m_pAdaptee = pAdaptee;}
virtual ~CAdapter(){}

public:
void Func(){m_pAdaptee->Func1();}

private:
CAdaptee *m_pAdaptee;

};

void main()
{
CAdaptee *pAdaptee = new CAdaptee();
CTarget *pTarget = new CAdapter(pAdaptee);
pTarget->Func();
delete pTarget;
delete pAdaptee;
}

tiger 2007-04-13 09:47 发表评论

设计模式(Facade)

tiger — Fri, 13 Apr 2007 01:44:00 GMT

#include
using namespace std;

class CSubSystem1
{
public:
CSubSystem1(){}
virtual ~CSubSystem1(){}

public:
void Func(){cout<<"SubSystem1!"<

};

class CSubSystem2
{
public:
CSubSystem2(){}
virtual ~CSubSystem2(){}

public:
void Func(){cout<<"SubSystem2!"<

};

class CFacade
{
public:
CFacade();
virtual ~CFacade();

public:
void Func();

private:
CSubSystem1 *m_pSubSystem1;
CSubSystem2 *m_pSubSystem2;

};

CFacade::CFacade()
{
m_pSubSystem1 = new CSubSystem1();
m_pSubSystem2 = new CSubSystem2();
}

CFacade::~CFacade()
{
delete m_pSubSystem1;
delete m_pSubSystem2;
}

void CFacade::Func()
{
m_pSubSystem1->Func();
m_pSubSystem2->Func();
}

void main()
{
CFacade *pFacade = new CFacade();
pFacade->Func();
delete pFacade;
}

tiger 2007-04-13 09:44 发表评论

用文件模拟实现C++输出流cout(函数指针)

tiger — Thu, 11 Jan 2007 08:13:00 GMT

本例通过操作符重载、函数重载及函数指针等相关技术模拟实现C++输出流，具体代码如下：
//FileStream.h
// FileStream.h: interface for the CFileStream class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_FILESTREAM_H__38C31298_92F6_4273_B6CF_C9718B5B5D69__INCLUDED_)
#define AFX_FILESTREAM_H__38C31298_92F6_4273_B6CF_C9718B5B5D69__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include

class CFileStream
{
public:
CFileStream();
virtual ~CFileStream();

public:
bool Open(char const* const pchFileName); //打开文件
bool Close(void); //关闭文件

public:
CFileStream& operator<<(int nData);
CFileStream& operator<<(float fData);
CFileStream& operator<<(char chData);

CFileStream& operator<<(int (*Func)(const int &nData));

private:
ofstream m_OutFile;

};

#endif // !defined(AFX_FILESTREAM_H__38C31298_92F6_4273_B6CF_C9718B5B5D69__INCLUDED_)

//FileStream.cpp
// FileStream.cpp: implementation of the CFileStream class.
//
//////////////////////////////////////////////////////////////////////

#include "FileStream.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CFileStream::CFileStream()
{

}

CFileStream::~CFileStream()
{

}

//打开文件
bool CFileStream::Open(char const* const pchFileName)
{
m_OutFile.open(pchFileName, ios::binary | ios::in, 0);
return true;
}

//关闭文件
bool CFileStream::Close()
{
m_OutFile.close();
return true;
}

CFileStream& CFileStream::operator<<(int nData)
{
m_OutFile< return *this;
}

CFileStream& CFileStream::operator<<(float fData)
{
m_OutFile< return *this;
}

CFileStream& CFileStream::operator<<(char chData)
{
m_OutFile< return *this;
}

CFileStream& CFileStream::operator<<(int (*Func)(const int &nData))
{
m_OutFile< return *this;
}

//main
#include "FileStream.h"

int Func(const int &nData)
{
return nData;
}

void main(void)
{
CFileStream file;
file.Open("C:\\tiger.txt");

file<<3<<4.5f<<'f';
file<<4<<6.78f<<'r';

file<

file.Close();

cout<<"文件写入完毕!"<}

tiger 2007-01-11 16:13 发表评论

C++技巧

tiger — Thu, 11 Jan 2007 02:23:00 GMT

1、获取数组大小：
#include
using namespace std;

void main(void)
{
float fArray[6] = {0.0f};
cout<< sizeof(fArray) / sizeof(fArray[0])<}
除系统内建数据类型可以按此方式外，自定义结构体也适用。

2、结构体初始化：
#include
using namespace std;

typedef struct tagTest
{
int nData;
float fData;
char chData;
}TEST;

void main(void)
{
TEST test[3] = {{1, 1.1f, 'a'},
{2, 2.2f, 'b'},
{3, 3.3f, 'c'}};

for(int i = 0; i < sizeof(test) / sizeof(test[0]); i++)
{
cout< cout<<"nData: "< cout<<"fData: "< cout<<"chData: "< cout< }
}

3、调用构造函数初始化数组：
#include
using namespace std;

class CTest
{
public:
CTest(int nData, float fData);
virtual ~CTest(void);

public:
void Display(void);

private:
int m_nData;
float m_fData;
};

CTest::CTest(int nData, float fData)
:m_nData(nData), m_fData(fData)
{
}

CTest::~CTest()
{
}

void CTest::Display()
{
cout<<"nData: "< cout<<"fData: "<}

void main(void)
{
CTest test[3] = {CTest(1, 1.1f), CTest(2, 2.2f), CTest(3, 3.3f)};

for(int i = 0; i < sizeof(test) / sizeof(test[0]); i++)
{
cout< test[i].Display();
cout< }
}

4、用atexit函数代替exit、abort函数
对象的析构函数在程序从main函数退出时，或者标准C库函数exit被调用时才会被调用，多数情况下main函数的结尾也是靠调用

exit函数来结束程序的，这意味着在main函数结束前调用exit或abort函数时十分危险的，可以通过一下例子证明：
1)、未调用exit或abort函数：
#include
using namespace std;

class CTest
{
public:
CTest(void){cout<<"CTest()"< virtual ~CTest(void){cout<<"~CTest()"<

};

void main(void)
{
CTest test;
}

程序执行结果：
CTest()
~CTest()

2)、调用exit或abort函数：
void main(void)
{
CTest test;
exit(0); //或abort();
}
程序执行结果：
CTest()

从上面的例子可以明确的看到调用exit或abort函数以后对象的析构函数未被调用，这无意间就导致了内存泄漏，而且这种错误

无法察觉。但是在实际情况中确实存在程序运行期间要求退出应用程序的需求，那么我们是否就束手无策呢？答案并非如此。我

们可以调用标准C库函数atexit，atexit函数确保所有的析构函数被调用，其具体代码如下：
3)、调用atexit函数：
void main(void)
{
CTest test;
atexit(0);
}

程序执行结果：
CTest()
~CTest()

5、存取全局函数的函数指针
#include
using namespace std;

void Func(const int &nData)
{
cout<}

typedef void (*pFunc)(const int &nData);
class CTest
{
public:
CTest(void){}
virtual ~CTest(void){}

public:
void SetFunc(pFunc p){m_pFunc = p;}
void Run(int nData){m_pFunc(nData); }

public:
pFunc m_pFunc;

};

void main(void)
{
CTest test;
test.SetFunc(Func);
test.Run(456);
}

tiger 2007-01-11 10:23 发表评论

友元

tiger — Wed, 10 Jan 2007 09:36:00 GMT

1、友元函数：
#include
using namespace std;

class CTest
{
public:
CTest(void){}
virtual ~CTest(void){}

public:
friend void Func(CTest t);

private:
void Display(void){cout<

private:
int m_nData;
};

void Func(CTest t)
{
t.m_nData = 6;
t.Display();
}

void main(void)
{
CTest t;
Func(t);
}

2、友元对象
#include
using namespace std;

class CStudent;
class CTeacher
{
public:
void SetValue(const CStudent &student);
int GetValue(void);

private:
int m_nMemberData;
};

class CStudent
{
public:
CStudent(const int &nMemberData){m_nMemberData = nMemberData;}

public:
friend class CTeacher;

private:
int m_nMemberData;
};

void CTeacher::SetValue(const CStudent &student)
{
m_nMemberData = student.m_nMemberData;
}

int CTeacher::GetValue()
{
return m_nMemberData;
}

void main(void)
{
CTeacher teacher;
CStudent student(11);

teacher.SetValue(student);
cout<}

3、友元类
方法一：
#include
using namespace std;

class CTest;
class CTest1
{
public:
CTest1(int nData){m_nData = nData;}
virtual ~CTest1(void){}

public:
friend CTest;

private:
int m_nData;
};

class CTest
{
public:
CTest(void){}
virtual ~CTest(void){}

public:
void Func(CTest1 t){cout<

};

void main(void)
{
CTest test;
CTest1 test1(27);
test.Func(test1);
}

方法二：
#include
using namespace std;

class CTest1;

class CTest
{
public:
CTest(void){}
virtual ~CTest(void){}

public:
void Func(CTest1 *pTest1);

};

class CTest1
{
public:
CTest1(int nData){m_nData = nData;}
virtual ~CTest1(void){}

public:
friend CTest;

private:
int m_nData;
};

void CTest::Func(CTest1 *pTest1)
{
cout<m_nData<}

void main(void)
{
CTest test;
CTest1 test1(27);
test.Func(&test1);
}

4、嵌套友元
#include
using namespace std;

class CLevel1
{
public:
CLevel1(int nData);
virtual ~CLevel1(void);

public:
class CLevel2
{
public:
CLevel2(void);
virtual ~CLevel2(void);

public:
void Func(CLevel1 level1);

};

public:
friend CLevel1::CLevel2;

private:
int m_nData;

};

CLevel1::CLevel1(int nData) : m_nData(nData)
{
}

CLevel1::~CLevel1()
{
}

CLevel1::CLevel2::CLevel2()
{
}

CLevel1::CLevel2::~CLevel2()
{
}

void CLevel1::CLevel2::Func(CLevel1 level1)
{
cout<}

void main(void)
{
CLevel1 level1(100);
CLevel1::CLevel2 level2;
level2.Func(level1);
}

tiger 2007-01-10 17:36 发表评论

WinCE下带编辑与下拉功能的ListCtrl

tiger — Wed, 10 Jan 2007 02:47:00 GMT

CListCtrl带编辑功能与下拉功能的本质即在列表中嵌入CEdit和CComboBox控件，其具体代码如下所示：
//InPlaceEdit.h
#if !defined(AFX_INPLACEEDIT_H__175AEDFF_731E_4721_8399_DE406A465861__INCLUDED_)
#define AFX_INPLACEEDIT_H__175AEDFF_731E_4721_8399_DE406A465861__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CInPlaceEdit : public CEdit
{

public:

// Implementation

// Returns the instance of the class
static CInPlaceEdit* GetInstance();

// Deletes the instance of the class
static void DeleteInstance();

// Creates the Windows edit control and attaches it to the object
// Shows the edit ctrl
BOOL ShowEditCtrl(DWORD dwStyle, const RECT& rCellRect, CWnd* pParentWnd,
UINT uiResourceID, int iRowIndex, int iColumnIndex,
CString& strValidChars, CString& rstrCurSelection);

// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CInPlaceEdit)
public:
virtual BOOL PreTranslateMessage(MSG* pMsg);
//}}AFX_VIRTUAL

// Attributes
// afx_msg void OnPaste(WPARAM wParam, LPARAM lParam);

protected:
// Generated message map functions
//{{AFX_MSG(CInPlaceEdit)
afx_msg void OnKillFocus(CWnd* pNewWnd);
afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
//}}AFX_MSG

DECLARE_MESSAGE_MAP()

private:

// Implementation

// Constructor
CInPlaceEdit();

// Hide the copy constructor and operator =
CInPlaceEdit (CInPlaceEdit&) {}

operator = (CInPlaceEdit) {}

// Destructor
virtual ~CInPlaceEdit();

// Attributes

// Index of the item in the list control
int m_iRowIndex;

// Index of the subitem in the list control
int m_iColumnIndex;

// To indicate whether ESC key was pressed
BOOL m_bESC;

// Valid characters
CString m_strValidChars;

// Singleton instance
static CInPlaceEdit* m_pInPlaceEdit;

// Previous string value in the edit control
CString m_strWindowText;
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_INPLACEEDIT_H__175AEDFF_731E_4721_8399_DE406A465861__INCLUDED_)

//InPlaceEdit.cpp
#include "stdafx.h"
#include "InPlaceEdit.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define CTRL_C 0x3
#define CTRL_V 0x16
#define CTRL_X 0x18

/////////////////////////////////////////////////////////////////////////////
// CInPlaceEdit

CInPlaceEdit* CInPlaceEdit::m_pInPlaceEdit = NULL;

CInPlaceEdit::CInPlaceEdit()
{
m_iRowIndex= -1;
m_iColumnIndex = -1;
m_bESC = FALSE;
m_strValidChars.Empty();
}

CInPlaceEdit::~CInPlaceEdit()
{
}

BEGIN_MESSAGE_MAP(CInPlaceEdit, CEdit)
//{{AFX_MSG_MAP(CInPlaceEdit)
ON_WM_KILLFOCUS()
ON_WM_CHAR()
ON_WM_CREATE()
//}}AFX_MSG_MAP
// ON_MESSAGE(WM_PASTE, OnPaste)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CInPlaceEdit message handlers
/*
void CInPlaceEdit::OnPaste(WPARAM , LPARAM )
{
if (m_strValidChars.IsEmpty())
{
return;
}

CString strFromClipboard;

// get the text from clipboard
if(OpenClipboard()) {
  HANDLE l_hData = GetClipboardData(CF_TEXT);
  if(NULL == l_hData) {
   return;
  }

  char *l_pBuffer = (char*)GlobalLock(l_hData);
  if(NULL != l_pBuffer) {
   strFromClipboard = l_pBuffer;
  }

GlobalUnlock(l_hData);
CloseClipboard();
}

// Validate the characters before pasting
for(int iCounter_ = 0; iCounter_ < strFromClipboard.GetLength(); iCounter_++)
{
  if (-1 == m_strValidChars.Find(strFromClipboard.GetAt(iCounter_)))
  {
   return;
  }
}

//let the individual control handle other processing
CEdit::Default();
}
*/

void CInPlaceEdit::OnKillFocus(CWnd* pNewWnd)
{
CEdit::OnKillFocus(pNewWnd);

// TODO: Add your message handler code here

// Get the text in the edit ctrl
CString strEdit;
GetWindowText(strEdit);

// if(strEdit.GetLength() == 1)
// strEdit = _T("0") + strEdit;

// Send Notification to parent of edit ctrl
LV_DISPINFO dispinfo;
dispinfo.hdr.hwndFrom = GetParent()->m_hWnd;
dispinfo.hdr.idFrom = GetDlgCtrlID();
dispinfo.hdr.code = LVN_ENDLABELEDIT;

dispinfo.item.mask = LVIF_TEXT;
dispinfo.item.iItem = m_iRowIndex;
dispinfo.item.iSubItem = m_iColumnIndex;
dispinfo.item.pszText = m_bESC ? LPTSTR((LPCTSTR)m_strWindowText) : LPTSTR((LPCTSTR)strEdit);
dispinfo.item.cchTextMax = m_bESC ? m_strWindowText.GetLength() : strEdit.GetLength();

GetParent()->SendMessage(WM_NOTIFY, GetParent()->GetDlgCtrlID(), (LPARAM)&dispinfo);

PostMessage(WM_CLOSE);
}

void CInPlaceEdit::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
// TODO: Add your message handler code here and/or call default

  if ((m_strValidChars.IsEmpty()) || ((-1 != m_strValidChars.Find(static_cast (nChar))) ||
  (nChar == VK_BACK) || (nChar == CTRL_C) || (nChar == CTRL_V) || (nChar == CTRL_X)))
{
  CEdit::OnChar(nChar, nRepCnt, nFlags);
}
else
{
  MessageBeep(MB_ICONEXCLAMATION);
  return;
}
}

BOOL CInPlaceEdit::PreTranslateMessage(MSG* pMsg)
{
// TODO: Add your specialized code here and/or call the base class
if (WM_KEYDOWN == pMsg->message && (VK_ESCAPE == pMsg->wParam || VK_RETURN == pMsg->wParam))
{
  if (VK_ESCAPE == pMsg->wParam)
  {
   m_bESC = TRUE;
  }

GetParent()->SetFocus();
return TRUE;
}

return CEdit::PreTranslateMessage(pMsg);
}

int CInPlaceEdit::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CEdit::OnCreate(lpCreateStruct) == -1)
return -1;

// TODO: Add your specialized creation code here
// Set the proper font
CFont* pFont = GetParent()->GetFont();
SetFont(pFont);

ShowWindow(SW_SHOW);
SetWindowText(m_strWindowText);
SetSel(0, -1);
SetFocus();

return 0;
}

CInPlaceEdit* CInPlaceEdit::GetInstance()
{
if(m_pInPlaceEdit == NULL)
{
m_pInPlaceEdit = new CInPlaceEdit;
}
return m_pInPlaceEdit;
}

void CInPlaceEdit::DeleteInstance()
{
delete m_pInPlaceEdit;
m_pInPlaceEdit = NULL;
}

BOOL CInPlaceEdit::ShowEditCtrl(DWORD dwStyle, const RECT &rCellRect, CWnd* pParentWnd,
UINT uiResourceID, int iRowIndex, int iColumnIndex,
CString& strValidChars, CString& rstrCurSelection)
{
m_iRowIndex = iRowIndex;
m_iColumnIndex = iColumnIndex;
m_strValidChars = strValidChars;
m_strWindowText = rstrCurSelection;
m_bESC = FALSE;

if (NULL == m_pInPlaceEdit->m_hWnd)
{
return m_pInPlaceEdit->Create(dwStyle, rCellRect, pParentWnd, uiResourceID);
}

return TRUE;
}

//InPlaceCombo.h
#if !defined(AFX_INPLACECOMBO_H__2E04D8D9_827F_4FBD_9E87_30AF8C31639D__INCLUDED_)
#define AFX_INPLACECOMBO_H__2E04D8D9_827F_4FBD_9E87_30AF8C31639D__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CInPlaceCombo : public CComboBox
{
public:

// Implementation

// Returns the instance of the class
static CInPlaceCombo* GetInstance();

// Deletes the instance of the class
static void DeleteInstance();

// Creates the Windows combo control and attaches it to the object, if needed and shows the combo ctrl
BOOL ShowComboCtrl(DWORD dwStyle, const CRect& rCellRect, CWnd* pParentWnd, UINT uiResourceID,
int iRowIndex, int iColumnIndex, CStringList* pDropDownList, CString strCurSelecetion = "", int iCurSel = -1);

// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CInPlaceCombo)
public:
virtual BOOL PreTranslateMessage(MSG* pMsg);
//}}AFX_VIRTUAL

protected:

// Generated message map functions
//{{AFX_MSG(CInPlaceCombo)
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnKillFocus(CWnd* pNewWnd);
afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
afx_msg void OnCloseup();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()

private:

// Implementation
// Constructor
CInPlaceCombo();

// Hide the copy constructor and operator =
CInPlaceCombo (CInPlaceCombo&) {}

operator = (CInPlaceCombo) {}

// Destructor
virtual ~CInPlaceCombo();

// Attributes

// Index of the item in the list control
int m_iRowIndex;

// Index of the subitem in the list control
int m_iColumnIndex;

// To indicate whether ESC key was pressed
BOOL m_bESC;

// Singleton instance
static CInPlaceCombo* m_pInPlaceCombo;

// Previous selected string value in the combo control
CString m_strWindowText;

// List of items to be shown in the drop down
CStringList m_DropDownList;
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_INPLACECOMBO_H__2E04D8D9_827F_4FBD_9E87_30AF8C31639D__INCLUDED_)

//InPlaceCombo.cpp
#include "stdafx.h"
#include "InPlaceCombo.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CInPlaceCombo

CInPlaceCombo* CInPlaceCombo::m_pInPlaceCombo = NULL;

CInPlaceCombo::CInPlaceCombo()
{
m_iRowIndex = -1;
m_iColumnIndex = -1;
m_bESC = FALSE;
}

CInPlaceCombo::~CInPlaceCombo()
{
}

BEGIN_MESSAGE_MAP(CInPlaceCombo, CComboBox)
//{{AFX_MSG_MAP(CInPlaceCombo)
ON_WM_CREATE()
ON_WM_KILLFOCUS()
ON_WM_CHAR()
ON_CONTROL_REFLECT(CBN_CLOSEUP, OnCloseup)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CInPlaceCombo message handlers

int CInPlaceCombo::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CComboBox::OnCreate(lpCreateStruct) == -1)
{
return -1;
}

// Set the proper font
CFont* pFont = GetParent()->GetFont();
SetFont(pFont);

SetFocus();

ResetContent();
for (POSITION Pos_ = m_DropDownList.GetHeadPosition(); Pos_ != NULL;)
{
AddString((LPCTSTR) (m_DropDownList.GetNext(Pos_)));
}

return 0;
}

BOOL CInPlaceCombo::PreTranslateMessage(MSG* pMsg)
{
// If the message if for "Enter" or "Esc"
// Do not process
if (pMsg->message == WM_KEYDOWN)
{
  if(pMsg->wParam == VK_RETURN || pMsg->wParam == VK_ESCAPE)
  {
   ::TranslateMessage(pMsg);
   ::DispatchMessage(pMsg);
   // DO NOT process further
   return TRUE;
  }
}

return CComboBox::PreTranslateMessage(pMsg);
}

void CInPlaceCombo::OnKillFocus(CWnd* pNewWnd)
{
CComboBox::OnKillFocus(pNewWnd);

// Get the current selection text
CString str;
GetWindowText(str);

// Send Notification to parent of ListView ctrl
LV_DISPINFO dispinfo;
dispinfo.hdr.hwndFrom = GetParent()->m_hWnd;
dispinfo.hdr.idFrom = GetDlgCtrlID();
dispinfo.hdr.code = LVN_ENDLABELEDIT;

dispinfo.item.mask = LVIF_TEXT;
dispinfo.item.iItem = m_iRowIndex;
dispinfo.item.iSubItem = m_iColumnIndex;
dispinfo.item.pszText = m_bESC ? LPTSTR((LPCTSTR)m_strWindowText) : LPTSTR((LPCTSTR)str);
dispinfo.item.cchTextMax = m_bESC ? m_strWindowText.GetLength() : str.GetLength();

GetParent()->SendMessage(WM_NOTIFY, GetParent()->GetDlgCtrlID(), (LPARAM)&dispinfo);

// Close the control
PostMessage(WM_CLOSE);
}

void CInPlaceCombo::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
// If the key is "Esc" set focus back to the list control
if (nChar == VK_ESCAPE || nChar == VK_RETURN)
{
  if (nChar == VK_ESCAPE)
  {
   m_bESC = TRUE;
  }

GetParent()->SetFocus();
return;
}

CComboBox::OnChar(nChar, nRepCnt, nFlags);
}

void CInPlaceCombo::OnCloseup()
{
// Set the focus to the parent list control
GetParent()->SetFocus();
}

CInPlaceCombo* CInPlaceCombo::GetInstance()
{
if(m_pInPlaceCombo == NULL)
{
m_pInPlaceCombo = new CInPlaceCombo;
}
return m_pInPlaceCombo;
}

void CInPlaceCombo::DeleteInstance()
{
delete m_pInPlaceCombo;
m_pInPlaceCombo = NULL;
}

BOOL CInPlaceCombo::ShowComboCtrl(DWORD dwStyle, const CRect &rCellRect, CWnd* pParentWnd, UINT uiResourceID,
int iRowIndex, int iColumnIndex, CStringList* pDropDownList,
CString strCurSelecetion /*= ""*/, int iCurSel /*= -1*/)
{

m_iRowIndex = iRowIndex;
m_iColumnIndex = iColumnIndex;
m_bESC = FALSE;

m_DropDownList.RemoveAll();
m_DropDownList.AddTail(pDropDownList);

BOOL bRetVal = TRUE;

if (-1 != iCurSel)
{
  GetLBText(iCurSel, m_strWindowText);
}
else if (!strCurSelecetion.IsEmpty())
{
  m_strWindowText = strCurSelecetion;
}

if (NULL == m_pInPlaceCombo->m_hWnd)
{
  bRetVal = m_pInPlaceCombo->Create(dwStyle, rCellRect, pParentWnd, uiResourceID);
}

SetCurSel(iCurSel);

return bRetVal;
}

//MyComboListCtrl.h
#if !defined(AFX_MYCOMBOLISTCTRL_H__9089600F_374F_4BFC_9482_DEAC0E7133E8__INCLUDED_)
#define AFX_MYCOMBOLISTCTRL_H__9089600F_374F_4BFC_9482_DEAC0E7133E8__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

//the max listCtrl columns
#define MAX_LISTCTRL_COLUMNS 100

#include
#include

class CInPlaceCombo;
class CInPlaceEdit;

// User define message
// This message is posted to the parent
// The message can be handled to make the necessary validations, if any
#define WM_VALIDATE WM_USER + 0x7FFD

// User define message
// This message is posted to the parent
// The message should be handled to spcify the items to the added to the combo
#define WM_SET_ITEMS WM_USER + 0x7FFC

class CMyComboListCtrl : public CListCtrl
{
public:

// Implementation
typedef enum {MODE_READONLY,MODE_DIGITAL_EDIT,MODE_TEXT_EDIT,MODE_COMBO} COMBOLISTCTRL_COLUMN_MODE;

// Constructor
CMyComboListCtrl();

// Destructor
virtual ~CMyComboListCtrl();

// Sets/Resets the column which support the in place combo box
void SetComboColumns(int iColumnIndex, bool bSet = true);

// Sets/Resets the column which support the in place edit control
void SetReadOnlyColumns(int iColumnIndex, bool bSet = true);

// Sets the valid characters for the edit ctrl
void SetValidEditCtrlCharacters(CString& rstrValidCharacters);

// Sets the vertical scroll
void EnableVScroll(bool bEnable = true);

// Sets the horizontal scroll
void EnableHScroll(bool bEnable = true);

//insert column
int CMyComboListCtrl::InsertColumn(int nCol,LPCTSTR lpszColumnHeading,int nFormat = LVCFMT_LEFT,int nWidth = -1,int nSubItem = -1);

//Get column counts
int GetColumnCounts();

//delete all column
void DeleteAllColumn();

//set column Valid char string
void SetColumnValidEditCtrlCharacters(CString &rstrValidCharacters,int column = -1);

// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CMyComboListCtrl)
//}}AFX_VIRTUAL

protected:

// Methods
// Generated message map functions
//{{AFX_MSG(CMyComboListCtrl)
afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnEndLabelEdit(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnBeginLabelEdit(NMHDR* pNMHDR, LRESULT* pResult);
//}}AFX_MSG

DECLARE_MESSAGE_MAP()

private:

// Implementation

// Returns the row & column index of the column on which mouse click event has occured
bool HitTestEx(CPoint& rHitPoint, int* pRowIndex, int* pColumnIndex) const;

// Creates and displays the in place combo box
CInPlaceCombo* ShowInPlaceList(int iRowIndex, int iColumnIndex, CStringList& rComboItemsList,
CString strCurSelecetion = "", int iSel = -1);

// Creates and displays the in place edit control
CInPlaceEdit* ShowInPlaceEdit(int iRowIndex, int iColumnIndex, CString& rstrCurSelection);

// Calculates the cell rect
void CalculateCellRect(int iColumnIndex, int iRowIndex, CRect& robCellRect);

// Checks whether column supports in place combo box
bool IsCombo(int iColumnIndex);

// Checks whether column is read only
bool IsReadOnly(int iColumnIndex);

// Scrolls the list ctrl to bring the in place ctrl to the view
void ScrollToView(int iColumnIndex, /*int iOffSet, */CRect& obCellRect);

// Attributes

// List of columns that support the in place combo box
CList m_ComboSupportColumnsList;

// List of columns that are read only
CList m_ReadOnlyColumnsList;

// Valid characters
CString m_strValidEditCtrlChars;

// The window style of the in place edit ctrl
DWORD m_dwEditCtrlStyle;

// The window style of the in place combo ctrl
DWORD m_dwDropDownCtrlStyle;

//columnCounts
int m_iColumnCounts;

//column types
COMBOLISTCTRL_COLUMN_MODE m_modeColumn[MAX_LISTCTRL_COLUMNS];

//column
CString m_strValidChars[MAX_LISTCTRL_COLUMNS];
//int m_
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_MYCOMBOLISTCTRL_H__9089600F_374F_4BFC_9482_DEAC0E7133E8__INCLUDED_)

//MyComboListCtrl.cpp
#include "stdafx.h"
#include "MyComboListCtrl.h"
#include "InPlaceCombo.h"
#include "InPlaceEdit.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

//#defines
#define FIRST_COLUMN 0
#define MIN_COLUMN_WIDTH 10
#define MAX_DROP_DOWN_ITEM_COUNT 10

/////////////////////////////////////////////////////////////////////////////
// CMyComboListCtrl

CMyComboListCtrl::CMyComboListCtrl()
{
m_iColumnCounts = 0;
m_ComboSupportColumnsList.RemoveAll();
m_ReadOnlyColumnsList.RemoveAll();
m_strValidEditCtrlChars.Empty();
m_dwEditCtrlStyle = ES_AUTOHSCROLL | ES_AUTOVSCROLL | ES_LEFT | ES_NOHIDESEL;
m_dwDropDownCtrlStyle = WS_BORDER | WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL | ES_AUTOVSCROLL |
CBS_DROPDOWNLIST | CBS_DISABLENOSCROLL;
}

CMyComboListCtrl::~CMyComboListCtrl()
{
CInPlaceCombo::DeleteInstance();
CInPlaceEdit::DeleteInstance();
}

BEGIN_MESSAGE_MAP(CMyComboListCtrl, CListCtrl)
//{{AFX_MSG_MAP(CMyComboListCtrl)
ON_WM_HSCROLL()
ON_WM_VSCROLL()
ON_WM_LBUTTONDOWN()
ON_NOTIFY_REFLECT(LVN_ENDLABELEDIT, OnEndLabelEdit)
ON_NOTIFY_REFLECT(LVN_BEGINLABELEDIT, OnBeginLabelEdit)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CMyComboListCtrl message handlers

CInPlaceCombo* CMyComboListCtrl::ShowInPlaceList(int iRowIndex, int iColumnIndex, CStringList& rComboItemsList,
CString strCurSelecetion /*= ""*/, int iSel /*= -1*/)
{
// The returned obPointer should not be saved

// Make sure that the item is visible
if (!EnsureVisible(iRowIndex, TRUE))
{
return NULL;
}

// Make sure that iColumnIndex is valid
CHeaderCtrl* pHeader = static_cast (GetDlgItem(FIRST_COLUMN));

int iColumnCount = pHeader->GetItemCount();

if (iColumnIndex >= iColumnCount || GetColumnWidth(iColumnIndex) < MIN_COLUMN_WIDTH)
{
return NULL;
}

// Calculate the rectangle specifications for the combo box
CRect obCellRect(0, 0, 0, 0);
CalculateCellRect(iColumnIndex, iRowIndex, obCellRect);

int iHeight = obCellRect.Height();
int iCount = (int )rComboItemsList.GetCount();

iCount = (iCount < MAX_DROP_DOWN_ITEM_COUNT) ?
iCount + MAX_DROP_DOWN_ITEM_COUNT : (MAX_DROP_DOWN_ITEM_COUNT + 1);

obCellRect.bottom += iHeight * iCount;

// Create the in place combobox
CInPlaceCombo* pInPlaceCombo = CInPlaceCombo::GetInstance();
pInPlaceCombo->ShowComboCtrl(m_dwDropDownCtrlStyle, obCellRect, this, 0, iRowIndex, iColumnIndex, &rComboItemsList,
strCurSelecetion, iSel);

return pInPlaceCombo;
}

CInPlaceEdit* CMyComboListCtrl::ShowInPlaceEdit(int iRowIndex, int iColumnIndex, CString& rstrCurSelection)
{
// Create an in-place edit control
CInPlaceEdit* pInPlaceEdit = CInPlaceEdit::GetInstance();

CRect obCellRect(0, 0, 0, 0);
CalculateCellRect(iColumnIndex, iRowIndex, obCellRect);

pInPlaceEdit->ShowEditCtrl(m_dwEditCtrlStyle, obCellRect, this, 0,
          iRowIndex, iColumnIndex,
          m_strValidChars[iColumnIndex], rstrCurSelection);

return pInPlaceEdit;
}

void CMyComboListCtrl::OnHScroll(UINT iSBCode, UINT iPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default

if (GetFocus() != this)
{
SetFocus();
}

CListCtrl::OnHScroll(iSBCode, iPos, pScrollBar);
}

void CMyComboListCtrl::OnVScroll(UINT iSBCode, UINT iPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default

if (GetFocus() != this)
{
SetFocus();
}

CListCtrl::OnVScroll(iSBCode, iPos, pScrollBar);
}

void CMyComboListCtrl::OnLButtonDown(UINT iFlags, CPoint obPoint)
{
// TODO: Add your message handler code here and/or call default

int iColumnIndex = -1;
int iRowIndex = -1;

// Get the current column and row
if (!HitTestEx(obPoint, &iRowIndex, &iColumnIndex))
{
return;
}

CListCtrl::OnLButtonDown(iFlags, obPoint);

// If column is not read only then
// If the SHIFT or CTRL key is down call the base class
// Check the high bit of GetKeyState to determine whether SHIFT or CTRL key is down
if ((GetKeyState(VK_SHIFT) & 0x80) || (GetKeyState(VK_CONTROL) & 0x80))
{
return;
}

// Get the current selection before creating the in place combo box
CString strCurSelection = GetItemText(iRowIndex, iColumnIndex);

if (-1 != iRowIndex)
{
  UINT flag = LVIS_FOCUSED;

  if ((GetItemState(iRowIndex, flag ) & flag) == flag)
  {
   // Add check for LVS_EDITLABELS
   if (GetWindowLong(m_hWnd, GWL_STYLE) & LVS_EDITLABELS)
   {
    // If combo box is supported
    // Create and show the in place combo box
    if (IsCombo(iColumnIndex))
    {
     CStringList obComboItemsList;

     GetParent()->SendMessage(WM_SET_ITEMS, (WPARAM)iColumnIndex, (LPARAM)&obComboItemsList);

     CInPlaceCombo* pInPlaceComboBox = ShowInPlaceList(iRowIndex, iColumnIndex, obComboItemsList, strCurSelection);
     ASSERT(pInPlaceComboBox);

     // Set the selection to previous selection
     pInPlaceComboBox->SelectString(-1, strCurSelection);
    }
    // If combo box is not read only
    // Create and show the in place edit control
    else if (!IsReadOnly(iColumnIndex))
    {
     CInPlaceEdit* pInPlaceEdit = ShowInPlaceEdit(iRowIndex, iColumnIndex, strCurSelection);
    }
   }
  }
}
}

bool CMyComboListCtrl::HitTestEx(CPoint &obPoint, int* pRowIndex, int* pColumnIndex) const
{
if (!pRowIndex || !pColumnIndex)
{
return false;
}

// Get the row index
*pRowIndex = HitTest(obPoint, NULL);

if (pColumnIndex)
{
*pColumnIndex = 0;
}

// Make sure that the ListView is in LVS_REPORT
if ((GetWindowLong(m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
{
return false;
}

// Get the number of columns
CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);

int iColumnCount = pHeader->GetItemCount();

// Get bounding rect of item and check whether obPoint falls in it.
CRect obCellRect;
GetItemRect(*pRowIndex, &obCellRect, LVIR_BOUNDS);

if (obCellRect.PtInRect(obPoint))
{
  // Now find the column
  for (*pColumnIndex = 0; *pColumnIndex < iColumnCount; (*pColumnIndex)++)
  {
   int iColWidth = GetColumnWidth(*pColumnIndex);

   if (obPoint.x >= obCellRect.left && obPoint.x <= (obCellRect.left + iColWidth))
   {
    return true;
   }
   obCellRect.left += iColWidth;
  }
}
return false;
}

void CMyComboListCtrl::SetComboColumns(int iColumnIndex, bool bSet /*= true*/)
{
// If the Column Index is not present && Set flag is false
// Then do nothing
// If the Column Index is present && Set flag is true
// Then do nothing
POSITION Pos = m_ComboSupportColumnsList.Find(iColumnIndex);

// If the Column Index is not present && Set flag is true
// Then Add to list
if ((NULL == Pos) && bSet)
{
m_ComboSupportColumnsList.AddTail(iColumnIndex);
}

// If the Column Index is present && Set flag is false
// Then Remove from list
if ((NULL != Pos) && !bSet)
{
m_ComboSupportColumnsList.RemoveAt(Pos);
}
}

void CMyComboListCtrl::SetReadOnlyColumns(int iColumnIndex, bool bSet /*= true*/)
{
// If the Column Index is not present && Set flag is false
// Then do nothing
// If the Column Index is present && Set flag is true
// Then do nothing
POSITION Pos = m_ReadOnlyColumnsList.Find(iColumnIndex);

// If the Column Index is not present && Set flag is true
// Then Add to list
if ((NULL == Pos) && bSet)
{
m_ReadOnlyColumnsList.AddTail(iColumnIndex);
}

// If the Column Index is present && Set flag is false
// Then Remove from list
if ((NULL != Pos) && !bSet)
{
m_ReadOnlyColumnsList.RemoveAt(Pos);
}
}

bool CMyComboListCtrl::IsReadOnly(int iColumnIndex)
{
if (m_ReadOnlyColumnsList.Find(iColumnIndex))
{
return true;
}

return false;
}

bool CMyComboListCtrl::IsCombo(int iColumnIndex)
{
if (m_ComboSupportColumnsList.Find(iColumnIndex))
{
return true;
}

return false;
}

void CMyComboListCtrl::CalculateCellRect(int iColumnIndex, int iRowIndex, CRect& robCellRect)
{
GetItemRect(iRowIndex, &robCellRect, LVIR_BOUNDS);

CRect rcClient;
GetClientRect(&rcClient);

if (robCellRect.right > rcClient.right)
{
robCellRect.right = rcClient.right;
}

ScrollToView(iColumnIndex, robCellRect);
}

void CMyComboListCtrl::OnEndLabelEdit(NMHDR* pNMHDR, LRESULT* pResult)
{
LV_DISPINFO* pDispInfo = (LV_DISPINFO*)pNMHDR;
// TODO: Add your control notification handler code here

// Update the item text with the new text
SetItemText(pDispInfo->item.iItem, pDispInfo->item.iSubItem, pDispInfo->item.pszText);

GetParent()->SendMessage(WM_VALIDATE, GetDlgCtrlID(), (LPARAM)pDispInfo);

*pResult = 0;
}

void CMyComboListCtrl::SetValidEditCtrlCharacters(CString &rstrValidCharacters)
{
m_strValidEditCtrlChars = rstrValidCharacters;
}

void CMyComboListCtrl::SetColumnValidEditCtrlCharacters(CString &rstrValidCharacters,int column)
{
if(column>MAX_LISTCTRL_COLUMNS-1)
  return;
if(column == -1)
{
  for(int i=0;i  {
   m_strValidChars[i] = rstrValidCharacters;
  }
}
else
  m_strValidChars[column] = rstrValidCharacters;
}

void CMyComboListCtrl::EnableHScroll(bool bEnable /*= true*/)
{
if (bEnable)
{
m_dwDropDownCtrlStyle |= WS_HSCROLL;
}
else
{
m_dwDropDownCtrlStyle &= ~WS_HSCROLL;
}
}

void CMyComboListCtrl::EnableVScroll(bool bEnable /*= true*/)
{
if (bEnable)
{
m_dwDropDownCtrlStyle |= WS_VSCROLL;
}
else
{
m_dwDropDownCtrlStyle &= ~WS_VSCROLL;
}
}

void CMyComboListCtrl::ScrollToView(int iColumnIndex, /*int iOffSet, */CRect& robCellRect)
{
// Now scroll if we need to expose the column
CRect rcClient;
GetClientRect(&rcClient);

int iColumnWidth = GetColumnWidth(iColumnIndex);

// Get the column iOffset
int iOffSet = 0;
for (int iIndex_ = 0; iIndex_ < iColumnIndex; iIndex_++)
{
iOffSet += GetColumnWidth(iIndex_);
}

// If x1 of cell rect is < x1 of ctrl rect or
// If x1 of cell rect is > x1 of ctrl rect or **Should not ideally happen**
// If the width of the cell extends beyond x2 of ctrl rect then
// Scroll

CSize obScrollSize(0, 0);

if (((iOffSet + robCellRect.left) < rcClient.left) ||
  ((iOffSet + robCellRect.left) > rcClient.right))
{
  obScrollSize.cx = iOffSet + robCellRect.left;
}
else if ((iOffSet + robCellRect.left + iColumnWidth) > rcClient.right)
{
  obScrollSize.cx = iOffSet + robCellRect.left + iColumnWidth - rcClient.right;
}

Scroll(obScrollSize);
robCellRect.left -= obScrollSize.cx;

// Set the width to the column width
robCellRect.left += iOffSet;
robCellRect.right = robCellRect.left + iColumnWidth;
}

void CMyComboListCtrl::OnBeginLabelEdit(NMHDR* pNMHDR, LRESULT* pResult)
{
LV_DISPINFO* pDispInfo = (LV_DISPINFO*)pNMHDR;
// TODO: Add your control notification handler code here
if (IsReadOnly(pDispInfo->item.iSubItem))
{
*pResult = 1;
return;
}

*pResult = 0;
}

int CMyComboListCtrl::InsertColumn(int nCol,LPCTSTR lpszColumnHeading,int nFormat ,int nWidth,int nSubItem)
{
m_iColumnCounts++;
return CListCtrl::InsertColumn( nCol, lpszColumnHeading, nFormat, nWidth, nSubItem);
}

int CMyComboListCtrl::GetColumnCounts()
{
return m_iColumnCounts;
}

void CMyComboListCtrl::DeleteAllColumn()
{
for(int i=0;i {
DeleteColumn(0);
}
}

//应用
LRESULT CRTUProtocolIndexInfoBaseDlg::PopulateComboList(WPARAM wParam, LPARAM lParam)
{
// Get the Combobox window pointer
CComboBox* pInPlaceCombo = static_cast(GetFocus());

// Get the inplace combbox top left
CRect obWindowRect;

pInPlaceCombo->GetWindowRect(&obWindowRect);

CPoint obInPlaceComboTopLeft(obWindowRect.TopLeft());

// Get the active list
// Get the control window rect
// If the inplace combobox top left is in the rect then
// The control is the active control
CWnd *pFocusWnd = GetFocus();
pFocusWnd->GetWindowRect(&obWindowRect);

int iColIndex = (int)wParam;

CStringList* pComboList = reinterpret_cast(lParam);
pComboList->RemoveAll();

if(obWindowRect.PtInRect(obInPlaceComboTopLeft))
{
  if((iColIndex == 1) || (iColIndex == 2))
  {
   pComboList->AddTail(_T("是"));
   pComboList->AddTail(_T("否"));
  }
}
return true;
}

//初始化列
CFont font;
VERIFY(font.CreateFont(
    18,                        // nHeight
    0,                         // nWidth
    0,                         // nEscapement
    0,                         // nOrientation
    FW_NORMAL,                 // nWeight
    FALSE,                     // bItalic
    FALSE,                     // bUnderline
    0,                         // cStrikeOut
    ANSI_CHARSET,              // nCharSet
    OUT_DEFAULT_PRECIS,        // nOutPrecision
    CLIP_DEFAULT_PRECIS,       // nClipPrecision
    DEFAULT_QUALITY,           // nQuality
    DEFAULT_PITCH | FF_SWISS, // nPitchAndFamily
    _T("宋体")));
m_CtrlListBaseInfo.SetFont(&font);
m_CtrlListBaseInfo.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES);

m_CtrlListBaseInfo.InsertColumn(0, _T("序号"), LVCFMT_CENTER, 40);
m_CtrlListBaseInfo.InsertColumn(1, _T("有效标志"), LVCFMT_CENTER, 60);

m_CtrlListBaseInfo.SetReadOnlyColumns(0); //read only
m_CtrlListBaseInfo.SetReadOnlyColumns(1); //read only
m_CtrlListBaseInfo.SetComboColumns(1, TRUE);
m_CtrlListBaseInfo.EnableVScroll();

m_CtrlListBaseInfo.InsertColumn(2, _T("功能码"), LVCFMT_CENTER, 80);

CString strValidChars(_T("0123456789ABCDEFabcdef"));
m_CtrlListBaseInfo.SetColumnValidEditCtrlCharacters(strValidChars, 2);//HEX only edit

tiger 2007-01-10 10:47 发表评论

WinCE下可编辑的ListCtrl

tiger — Tue, 09 Jan 2007 04:29:00 GMT

和C++中一样，WinCE下可编辑的ListCtrl控件也是将Edit控件置于列表框中以达到可编辑的功能，在此我们需要重载CListCtrl和CEdit控件以完成其功能，具体代码如下：
//InPlaceEdit.h
#if !defined(AFX_INPLACEEDIT_H__175AEDFF_731E_4721_8399_DE406A465861__INCLUDED_)
#define AFX_INPLACEEDIT_H__175AEDFF_731E_4721_8399_DE406A465861__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CInPlaceEdit : public CEdit
{

public:

// Implementation

// Returns the instance of the class
static CInPlaceEdit* GetInstance();

// Deletes the instance of the class
static void DeleteInstance();

// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CInPlaceEdit)
public:
virtual BOOL PreTranslateMessage(MSG* pMsg);
//}}AFX_VIRTUAL

// Attributes
// afx_msg void OnPaste(WPARAM wParam, LPARAM lParam);

DECLARE_MESSAGE_MAP()

private:

// Implementation

// Constructor
CInPlaceEdit();

// Hide the copy constructor and operator =
CInPlaceEdit (CInPlaceEdit&) {}

operator = (CInPlaceEdit) {}

// Destructor
virtual ~CInPlaceEdit();

// Attributes

// Index of the item in the list control
int m_iRowIndex;

// Index of the subitem in the list control
int m_iColumnIndex;

// To indicate whether ESC key was pressed
BOOL m_bESC;

// Valid characters
CString m_strValidChars;

// Singleton instance
static CInPlaceEdit* m_pInPlaceEdit;

// Previous string value in the edit control
CString m_strWindowText;
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_INPLACEEDIT_H__175AEDFF_731E_4721_8399_DE406A465861__INCLUDED_)

//InPlaceEdit.cpp
#include "stdafx.h"
#include "InPlaceEdit.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

#define CTRL_C 0x3
#define CTRL_V 0x16
#define CTRL_X 0x18

/////////////////////////////////////////////////////////////////////////////
// CInPlaceEdit

CInPlaceEdit* CInPlaceEdit::m_pInPlaceEdit = NULL;

CInPlaceEdit::CInPlaceEdit()
{
m_iRowIndex= -1;
m_iColumnIndex = -1;
m_bESC = FALSE;
m_strValidChars.Empty();
}

CInPlaceEdit::~CInPlaceEdit()
{
}

BEGIN_MESSAGE_MAP(CInPlaceEdit, CEdit)
//{{AFX_MSG_MAP(CInPlaceEdit)
ON_WM_KILLFOCUS()
ON_WM_CHAR()
ON_WM_CREATE()
//}}AFX_MSG_MAP
// ON_MESSAGE(WM_PASTE, OnPaste)
END_MESSAGE_MAP()

CString strFromClipboard;

GlobalUnlock(l_hData);
CloseClipboard();
}

void CInPlaceEdit::OnKillFocus(CWnd* pNewWnd)
{
CEdit::OnKillFocus(pNewWnd);

// TODO: Add your message handler code here

// Get the text in the edit ctrl
CString strEdit;
GetWindowText(strEdit);

// Send Notification to parent of edit ctrl
LV_DISPINFO dispinfo;
dispinfo.hdr.hwndFrom = GetParent()->m_hWnd;
dispinfo.hdr.idFrom = GetDlgCtrlID();
dispinfo.hdr.code = LVN_ENDLABELEDIT;

PostMessage(WM_CLOSE);
}

void CInPlaceEdit::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags)
{
// TODO: Add your message handler code here and/or call default

GetParent()->SetFocus();
return TRUE;
}

return CEdit::PreTranslateMessage(pMsg);
}

ShowWindow(SW_SHOW);
SetWindowText(m_strWindowText);
SetSel(0, -1);
SetFocus();

return 0;
}

CInPlaceEdit* CInPlaceEdit::GetInstance()
{
if(m_pInPlaceEdit == NULL)
{
m_pInPlaceEdit = new CInPlaceEdit;
}
return m_pInPlaceEdit;
}

void CInPlaceEdit::DeleteInstance()
{
delete m_pInPlaceEdit;
m_pInPlaceEdit = NULL;
}

if (NULL == m_pInPlaceEdit->m_hWnd)
{
return m_pInPlaceEdit->Create(dwStyle, rCellRect, pParentWnd, uiResourceID);
}

return TRUE;
}

//ComboListCtrl.h
#if !defined(AFX_COMBOLISTCTRL_H__9089600F_374F_4BFC_9482_DEAC0E7133E8__INCLUDED_)
#define AFX_COMBOLISTCTRL_H__9089600F_374F_4BFC_9482_DEAC0E7133E8__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

//the max listCtrl columns
#define MAX_LISTCTRL_COLUMNS 100

#include

class CInPlaceEdit;

// User define message
// This message is posted to the parent
// The message can be handled to make the necessary validations, if any
#define WM_VALIDATE WM_USER + 0x7FFD

// User define message
// This message is posted to the parent
// The message should be handled to spcify the items to the added to the combo
#define WM_SET_ITEMS WM_USER + 0x7FFC

class CComboListCtrl : public CListCtrl
{
public:

// Implementation
typedef enum {MODE_READONLY,MODE_DIGITAL_EDIT,MODE_TEXT_EDIT,MODE_COMBO} COMBOLISTCTRL_COLUMN_MODE;

// Constructor
CComboListCtrl();

// Destructor
virtual ~CComboListCtrl();

// Sets/Resets the column which support the in place combo box

// Sets/Resets the column which support the in place edit control
void SetReadOnlyColumns(int iColumnIndex, bool bSet = true);

// Sets the valid characters for the edit ctrl
void SetValidEditCtrlCharacters(CString& rstrValidCharacters);

// Sets the vertical scroll

// Sets the horizontal scroll

//insert column
int CComboListCtrl::InsertColumn(int nCol,LPCTSTR lpszColumnHeading,int nFormat = LVCFMT_LEFT,int nWidth = -1,int nSubItem = -1);

//Get column counts
int GetColumnCounts();

//delete all column
void DeleteAllColumn();

//set column Valid char string
void SetColumnValidEditCtrlCharacters(CString &rstrValidCharacters,int column = -1);

// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CComboListCtrl)
//}}AFX_VIRTUAL

protected:

// Methods
// Generated message map functions
//{{AFX_MSG(CComboListCtrl)
afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
afx_msg void OnEndLabelEdit(NMHDR* pNMHDR, LRESULT* pResult);
afx_msg void OnBeginLabelEdit(NMHDR* pNMHDR, LRESULT* pResult);
//}}AFX_MSG

DECLARE_MESSAGE_MAP()

private:

// Implementation

// Returns the row & column index of the column on which mouse click event has occured
bool HitTestEx(CPoint& rHitPoint, int* pRowIndex, int* pColumnIndex) const;

// Creates and displays the in place combo box

// Creates and displays the in place edit control
CInPlaceEdit* ShowInPlaceEdit(int iRowIndex, int iColumnIndex, CString& rstrCurSelection);

// Calculates the cell rect
void CalculateCellRect(int iColumnIndex, int iRowIndex, CRect& robCellRect);

// Checks whether column supports in place combo box

// Checks whether column is read only
bool IsReadOnly(int iColumnIndex);

// Scrolls the list ctrl to bring the in place ctrl to the view
void ScrollToView(int iColumnIndex, /*int iOffSet, */CRect& obCellRect);

// Attributes

// List of columns that are read only
CList m_ReadOnlyColumnsList;

// Valid characters
CString m_strValidEditCtrlChars;

// The window style of the in place edit ctrl
DWORD m_dwEditCtrlStyle;

//columnCounts
int m_iColumnCounts;

//column types
COMBOLISTCTRL_COLUMN_MODE m_modeColumn[MAX_LISTCTRL_COLUMNS];

//column
CString m_strValidChars[MAX_LISTCTRL_COLUMNS];
//int m_
};

/////////////////////////////////////////////////////////////////////////////

//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.

#endif // !defined(AFX_COMBOLISTCTRL_H__9089600F_374F_4BFC_9482_DEAC0E7133E8__INCLUDED_)

//ComboListCtrl.cpp
#include "stdafx.h"
#include "ComboListCtrl.h"
#include "InPlaceEdit.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

//#defines
#define FIRST_COLUMN 0
#define MIN_COLUMN_WIDTH 10
#define MAX_DROP_DOWN_ITEM_COUNT 10

/////////////////////////////////////////////////////////////////////////////
// CComboListCtrl

CComboListCtrl::CComboListCtrl()
{
m_iColumnCounts = 0;
m_ReadOnlyColumnsList.RemoveAll();
m_strValidEditCtrlChars.Empty();
m_dwEditCtrlStyle = ES_AUTOHSCROLL | ES_AUTOVSCROLL | ES_LEFT | ES_NOHIDESEL;
}

CComboListCtrl::~CComboListCtrl()
{
CInPlaceEdit::DeleteInstance();
}

BEGIN_MESSAGE_MAP(CComboListCtrl, CListCtrl)
//{{AFX_MSG_MAP(CComboListCtrl)
ON_WM_HSCROLL()
ON_WM_VSCROLL()
ON_WM_LBUTTONDOWN()
ON_NOTIFY_REFLECT(LVN_ENDLABELEDIT, OnEndLabelEdit)
ON_NOTIFY_REFLECT(LVN_BEGINLABELEDIT, OnBeginLabelEdit)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CComboListCtrl message handlers

CInPlaceEdit* CComboListCtrl::ShowInPlaceEdit(int iRowIndex, int iColumnIndex, CString& rstrCurSelection)
{
// Create an in-place edit control
CInPlaceEdit* pInPlaceEdit = CInPlaceEdit::GetInstance();

CRect obCellRect(0, 0, 0, 0);
CalculateCellRect(iColumnIndex, iRowIndex, obCellRect);

pInPlaceEdit->ShowEditCtrl(m_dwEditCtrlStyle, obCellRect, this, 0,
          iRowIndex, iColumnIndex,
          m_strValidChars[iColumnIndex], rstrCurSelection);

return pInPlaceEdit;
}

void CComboListCtrl::OnHScroll(UINT iSBCode, UINT iPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default

if (GetFocus() != this)
{
SetFocus();
}

CListCtrl::OnHScroll(iSBCode, iPos, pScrollBar);
}

void CComboListCtrl::OnVScroll(UINT iSBCode, UINT iPos, CScrollBar* pScrollBar)
{
// TODO: Add your message handler code here and/or call default

if (GetFocus() != this)
{
SetFocus();
}

CListCtrl::OnVScroll(iSBCode, iPos, pScrollBar);
}

void CComboListCtrl::OnLButtonDown(UINT iFlags, CPoint obPoint)
{
// TODO: Add your message handler code here and/or call default

int iColumnIndex = -1;
int iRowIndex = -1;

// Get the current column and row
if (!HitTestEx(obPoint, &iRowIndex, &iColumnIndex))
{
return;
}

bool CComboListCtrl::HitTestEx(CPoint &obPoint, int* pRowIndex, int* pColumnIndex) const
{
if (!pRowIndex || !pColumnIndex)
{
return false;
}

// Get the row index
*pRowIndex = HitTest(obPoint, NULL);

if (pColumnIndex)
{
*pColumnIndex = 0;
}

// Make sure that the ListView is in LVS_REPORT
if ((GetWindowLong(m_hWnd, GWL_STYLE) & LVS_TYPEMASK) != LVS_REPORT)
{
return false;
}

// Get the number of columns
CHeaderCtrl* pHeader = (CHeaderCtrl*)GetDlgItem(0);

int iColumnCount = pHeader->GetItemCount();

void CComboListCtrl::SetReadOnlyColumns(int iColumnIndex, bool bSet /*= true*/)
{
// If the Column Index is not present && Set flag is false
// Then do nothing
// If the Column Index is present && Set flag is true
// Then do nothing
POSITION Pos = m_ReadOnlyColumnsList.Find(iColumnIndex);

// If the Column Index is not present && Set flag is true
// Then Add to list
if ((NULL == Pos) && bSet)
{
m_ReadOnlyColumnsList.AddTail(iColumnIndex);
}

// If the Column Index is present && Set flag is false
// Then Remove from list
if ((NULL != Pos) && !bSet)
{
m_ReadOnlyColumnsList.RemoveAt(Pos);
}
}

bool CComboListCtrl::IsReadOnly(int iColumnIndex)
{
if (m_ReadOnlyColumnsList.Find(iColumnIndex))
{
return true;
}

return false;
}

void CComboListCtrl::CalculateCellRect(int iColumnIndex, int iRowIndex, CRect& robCellRect)
{
GetItemRect(iRowIndex, &robCellRect, LVIR_BOUNDS);

CRect rcClient;
GetClientRect(&rcClient);

if (robCellRect.right > rcClient.right)
{
robCellRect.right = rcClient.right;
}

ScrollToView(iColumnIndex, robCellRect);
}

void CComboListCtrl::OnEndLabelEdit(NMHDR* pNMHDR, LRESULT* pResult)
{
LV_DISPINFO* pDispInfo = (LV_DISPINFO*)pNMHDR;
// TODO: Add your control notification handler code here

// Update the item text with the new text
SetItemText(pDispInfo->item.iItem, pDispInfo->item.iSubItem, pDispInfo->item.pszText);

GetParent()->SendMessage(WM_VALIDATE, GetDlgCtrlID(), (LPARAM)pDispInfo);

*pResult = 0;
}

void CComboListCtrl::SetValidEditCtrlCharacters(CString &rstrValidCharacters)
{
m_strValidEditCtrlChars = rstrValidCharacters;
}

void CComboListCtrl::SetColumnValidEditCtrlCharacters(CString &rstrValidCharacters,int column)
{
if(column>MAX_LISTCTRL_COLUMNS-1)
  return;
if(column == -1)
{
  for(int i=0;i  {
   m_strValidChars[i] = rstrValidCharacters;
  }
}
else
  m_strValidChars[column] = rstrValidCharacters;
}

void CComboListCtrl::ScrollToView(int iColumnIndex, /*int iOffSet, */CRect& robCellRect)
{
// Now scroll if we need to expose the column
CRect rcClient;
GetClientRect(&rcClient);

int iColumnWidth = GetColumnWidth(iColumnIndex);

// Get the column iOffset
int iOffSet = 0;
for (int iIndex_ = 0; iIndex_ < iColumnIndex; iIndex_++)
{
iOffSet += GetColumnWidth(iIndex_);
}

// If x1 of cell rect is < x1 of ctrl rect or
// If x1 of cell rect is > x1 of ctrl rect or **Should not ideally happen**
// If the width of the cell extends beyond x2 of ctrl rect then
// Scroll

CSize obScrollSize(0, 0);

Scroll(obScrollSize);
robCellRect.left -= obScrollSize.cx;

// Set the width to the column width
robCellRect.left += iOffSet;
robCellRect.right = robCellRect.left + iColumnWidth;
}

void CComboListCtrl::OnBeginLabelEdit(NMHDR* pNMHDR, LRESULT* pResult)
{
LV_DISPINFO* pDispInfo = (LV_DISPINFO*)pNMHDR;
// TODO: Add your control notification handler code here
if (IsReadOnly(pDispInfo->item.iSubItem))
{
*pResult = 1;
return;
}

*pResult = 0;
}

int CComboListCtrl::InsertColumn(int nCol,LPCTSTR lpszColumnHeading,int nFormat ,int nWidth,int nSubItem)
{
m_iColumnCounts++;
return CListCtrl::InsertColumn( nCol, lpszColumnHeading, nFormat, nWidth, nSubItem);
}

int CComboListCtrl::GetColumnCounts()
{
return m_iColumnCounts;
}

void CComboListCtrl::DeleteAllColumn()
{
for(int i=0;i {
DeleteColumn(0);
}
}

//应用
CComboListCtrl m_CtrlList;

m_CtrlList.InsertColumn(0, _T("编号"), LVCFMT_CENTER, 50);
m_CtrlList.InsertColumn(1, _T("姓名"), LVCFMT_CENTER, 80);
m_CtrlList.InsertColumn(2, _T("学号"), LVCFMT_CENTER, 80);
m_CtrlList.InsertColumn(3, _T("性别"), LVCFMT_CENTER, 80);

CString strValidChars;//
m_CtrlList.SetReadOnlyColumns(0);//read only

strValidChars = _T("");
m_CtrlList.SetColumnValidEditCtrlCharacters(strValidChars,1);//none control edit

strValidChars = _T("0123456789.");
m_CtrlList.SetColumnValidEditCtrlCharacters(strValidChars,2);//digital only edit

m_CtrlList.SetReadOnlyColumns(3);//read only

CFont font;
VERIFY(font.CreateFont(
    20,                        // nHeight
    0,                         // nWidth
    0,                         // nEscapement
    0,                         // nOrientation
    FW_NORMAL,                 // nWeight
    FALSE,                     // bItalic
    FALSE,                     // bUnderline
    0,                         // cStrikeOut
    ANSI_CHARSET,              // nCharSet
    OUT_DEFAULT_PRECIS,        // nOutPrecision
    CLIP_DEFAULT_PRECIS,       // nClipPrecision
    DEFAULT_QUALITY,           // nQuality
    DEFAULT_PITCH | FF_SWISS, // nPitchAndFamily
    _T("宋体")));
m_CtrlList.SetFont(&font);
m_CtrlList.SetExtendedStyle(LVS_EX_FULLROWSELECT | LVS_EX_GRIDLINES);

CString str;
for(int i=0;i<30;i++)
{
  str.Format(_T("%d"), i+1);
  m_CtrlList.InsertItem(i, str);
  m_CtrlList.SetItemText(i, 1, _T("张三"));
  m_CtrlList.SetItemText(i, 2, _T("1234"));
  m_CtrlList.SetItemText(i, 3, _T("男"));
}

tiger 2007-01-09 12:29 发表评论

WinCE数据库操作之CeCreateDatabaseEx

tiger — Tue, 09 Jan 2007 04:17:00 GMT

摘要: 与CCeDBDatabase类数据库相比，CeCreateDatabaseEx具有独特的优势，其创建路径可以指定的特性决定了其数据可以永久保存的固有优势，但相比CCeDBDatabase类数据库而言，CeCreateDatabaseEx完全应用api函数操作，其操作也相对复杂一些。Records允许的9种数据类型： ... 阅读全文

tiger 2007-01-09 12:17 发表评论

ADO数据库编程(WinCE)

tiger — Tue, 09 Jan 2007 04:03:00 GMT

与C++中ADO数据库编程一样，WinCE中ADO数据库操作也需要_Connection和_Recordset指针，在此我们将其封装以求更方便，注：WinCE系统必须支持数据库的ADO操作。具体代码如下所示：
//VOConnection.h

#if !defined(AFX_VOCONNECTION_H__EE2E886A_8A8A_4CC8_9A48_28681F64544B__INCLUDED_)
#define AFX_VOCONNECTION_H__EE2E886A_8A8A_4CC8_9A48_28681F64544B__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include
#include
#include "VOString.h"

class CVOConnection
{
public:
CVOConnection(LPCTSTR pcszProvider = NULL);
virtual ~CVOConnection();

BOOL Execute(LPCTSTR pcszSQL);
BOOL Initialize();
LPCTSTR GetProvider() { return m_strProvider; }

operator _Connection*() { return m_Conn; }

void SetConnectDB(LPCTSTR lpszDBName);
void ClearConnect();

protected:
CVOString m_strProvider;
static TCHAR*  g_ProgID;
static CLSID  g_ClsID;
static BOOL   g_Init;

_Connection* m_Conn;
};

#endif // !defined(AFX_VOCONNECTION_H__EE2E886A_8A8A_4CC8_9A48_28681F64544B__INCLUDED_)

//VOConnection.cpp
#include "stdafx.h"
#include
#include
#include "VOConnection.h"
#include "VORecordset.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

const IID IID__Connection = { 0x113033de, 0xf682, 0x11d2, { 0xbb, 0x62, 0x00, 0xc0, 0x4f, 0x68, 0x0a, 0xcc}};

void __stdcall _com_issue_error(HRESULT m_hr)
{
TCHAR pcszError[1024];

_stprintf(pcszError, TEXT("_com_issue_error(%ld)\n"), m_hr);
OutputDebugString(pcszError);
}

BOOL CVOConnection::g_Init = FALSE;
CLSID CVOConnection::g_ClsID;
TCHAR* CVOConnection::g_ProgID = TEXT("ADOCE.Connection.3.0");

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

extern CVOConnection m_Conn;

CVOConnection::CVOConnection(LPCTSTR pcszProvider) : m_Conn(NULL)
{

if(!g_Init)
Initialize();

HRESULT hr;

if(pcszProvider == NULL)
{
// pcszProvider = TEXT("cedb");

  hr = CoCreateInstance(g_ClsID, NULL, CLSCTX_INPROC_SERVER, IID__Connection, (LPVOID*) &m_Conn);
//  hr = m_Conn->put_Provider((LPTSTR)pcszProvider);
  hr = m_Conn->Open(TEXT("Disk\\tiger.mdb"),TEXT(""),TEXT(""),adOpenUnspecified);
}
else
{
  m_strProvider = pcszProvider;
  m_Conn = NULL;
}
}

CVOConnection::~CVOConnection()
{
if(m_Conn)
{
m_Conn->Close();
m_Conn->Release();
}
}

BOOL CVOConnection::Initialize()
{
if(FAILED(CoInitializeEx(NULL, COINIT_MULTITHREADED)))
return FALSE;

HRESULT hr;

hr = CLSIDFromProgID(g_ProgID, &g_ClsID);

if(FAILED(hr))
return FALSE;

return TRUE;
}

BOOL CVOConnection::Execute(LPCTSTR pcszSQL)
{
CVORecordset rs(*this);

return rs.Open(pcszSQL, adOpenForwardOnly, adLockPessimistic);
}

void CVOConnection::SetConnectDB(LPCTSTR lpszDBName)
{
if( m_Conn )
{
  m_Conn->Close();
  m_Conn->put_Provider((LPTSTR)(TEXT("cedb")));
  m_Conn->Open((LPTSTR)lpszDBName,TEXT(""),TEXT(""),adOpenUnspecified);
  m_strProvider = lpszDBName;
}
}

void CVOConnection::ClearConnect()
{
if( m_Conn )
{
  m_Conn->Close();
  m_Conn->put_Provider((LPTSTR)(TEXT("cedb")));
  m_Conn->Open(TEXT(""),TEXT(""),TEXT(""),adOpenUnspecified);
  m_strProvider = TEXT("");
}
}

//VORecordset.h
#if !defined(AFX_VORECORDSET_H__B81BD14E_98F0_42A7_A64F_3FA21F5A3E5D__INCLUDED_)
#define AFX_VORECORDSET_H__B81BD14E_98F0_42A7_A64F_3FA21F5A3E5D__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include
#include
#include "VOConnection.h"

class CVORecordset
{

public:
CVORecordset(CVOConnection& rConn);
virtual ~CVORecordset();

public:

LPCTSTR GetFieldValueString(int iField);
VARIANT GetFieldValue(int iField);
LPCTSTR GetFieldName(int iField);
Field* GetField(int iField);
long GetFieldCount() { return m_FldCnt; }

BOOL MoveNext();
BOOL MoveFirst();
BOOL IsEOF();
BOOL IsBOF();
BOOL Close();
// BOOL Open(LPCTSTR);
BOOL Open(LPCTSTR pcszSource, enum CursorTypeEnum CursorType, enum LockTypeEnum LockType);
BOOL Initialize();
BOOL IsOpen() { return m_fIsOpen; }
operator _Recordset*() { return m_rs; }

protected:
BOOL m_fIsOpen;
CVOConnection&  m_rConn;
_Recordset*   m_rs;
Fields*    m_Fields;
Field*    m_Field;
long    m_FldCnt;

static TCHAR*  g_ProgID;
static CLSID  g_ClsID;
static BOOL   g_Init;
};
#endif // !defined(AFX_VORECORDSET_H__B81BD14E_98F0_42A7_A64F_3FA21F5A3E5D__INCLUDED_)

//VORecordset.cpp
#include "stdafx.h"
#include "VORecordset.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

const IID IID__Recordset = { 0x113033f6, 0xf682, 0x11d2, { 0xbb, 0x62, 0x00, 0xc0, 0x4f, 0x68, 0x0a, 0xcc}};

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

BOOL CVORecordset::g_Init = FALSE;
CLSID CVORecordset::g_ClsID;
TCHAR* CVORecordset::g_ProgID = TEXT("ADOCE.Recordset.3.0");

CVORecordset::CVORecordset(CVOConnection& rConn) : m_rConn(rConn), m_rs(NULL)
{
if(!g_Init)
Initialize();

HRESULT hr;

hr = CoCreateInstance(g_ClsID, NULL, CLSCTX_INPROC_SERVER, IID__Recordset, (LPVOID*)&m_rs);

VARIANT varConn;

varConn.pdispVal = (_Connection*)m_rConn;
varConn.vt = VT_DISPATCH;
hr = m_rs->put_ActiveConnection(varConn);
}

CVORecordset::~CVORecordset()
{
Close();
if(m_rs)
m_rs->Release();
}

BOOL CVORecordset::Initialize()
{
HRESULT hr;

hr = CLSIDFromProgID( g_ProgID, &g_ClsID);

return(!FAILED(hr));
}

BOOL CVORecordset::Open(LPCTSTR pcszSource, enum CursorTypeEnum CursorType, enum LockTypeEnum LockType)
{
if(!m_rs)
{
TRACE(TEXT("CVORecordset::Open() RecordSet COM Object not initialized\n"));
return FALSE;
}

HRESULT hr;
m_rs->Close();
hr = m_rs->Open(_variant_t(pcszSource), _variant_t( TEXT("Disk\\tiger.mdb") ), CursorType, LockType, adCmdUnknown);
m_fIsOpen = (!FAILED(hr));

m_rs->get_Fields(&m_Fields);
m_Fields->get_Count(&m_FldCnt);

return m_fIsOpen;
}

BOOL CVORecordset::Close()
{
if(!m_rs)
{
TRACE(TEXT("CVORecordset::Close() RecordSet COM Object not initialized\n"));
return FALSE;
}

m_rs->Close();

m_fIsOpen = FALSE;
return TRUE;
}

BOOL CVORecordset::IsBOF()
{
if(!m_rs)
{
TRACE(TEXT("CVORecordset::BOF() RecordSet COM Object not initialized\n"));
return FALSE;
}

VARIANT_BOOL fValue;
HRESULT hr = m_rs->get_BOF(&fValue);

return (fValue == VARIANT_TRUE);
}

BOOL CVORecordset::IsEOF()
{
if(!m_rs)
{
TRACE(TEXT("CVORecordset::EOF() RecordSet COM Object not initialized\n"));
return FALSE;
}

VARIANT_BOOL fValue;
HRESULT hr = m_rs->get_EOF(&fValue);

return (fValue == VARIANT_TRUE);
}

BOOL CVORecordset::MoveFirst()
{
if(!m_rs)
{
TRACE(TEXT("CVORecordset::MoveFirst() RecordSet COM Object not initialized\n"));
return FALSE;
}

HRESULT hr = m_rs->MoveFirst();

return (!FAILED(hr));
}

BOOL CVORecordset::MoveNext()
{
if(!m_rs)
{
TRACE(TEXT("CVORecordset::MoveNext() RecordSet COM Object not initialized\n"));
return FALSE;
}

HRESULT hr = m_rs->MoveNext();

return (!FAILED(hr));
}

Field* CVORecordset::GetField(int iField)
{
if(!m_rs)
{
TRACE(TEXT("CVORecordset::GetField() RecordSet COM Object not initialized\n"));
return NULL;
}

HRESULT hr = m_Fields->get_Item(_variant_t((long)iField), &m_Field);

if(FAILED(hr))
return NULL;

return m_Field;
}

LPCTSTR CVORecordset::GetFieldName(int iField)
{
Field* pField = GetField(iField);

if(!pField)
{
TRACE(TEXT("CVORecordset::GetFieldName() Invalid Field Index\n"));
return NULL;
}

BSTR strFieldName;

pField->get_Name(&strFieldName);

return strFieldName;
}

VARIANT CVORecordset::GetFieldValue(int iField)
{
VARIANT value;
HRESULT hr;

VariantInit(&value);

Field* pField = GetField(iField);

if(!pField)
{
TRACE(TEXT("CVORecordset::GetFieldValue() Invalid Field Index\n"));
return _variant_t((long)0);
}

pField = GetField(iField);
hr = pField->get_Value(&value);

return value;
}

LPCTSTR CVORecordset::GetFieldValueString(int iField)
{
VARIANT value = GetFieldValue(iField);
VARIANT valueString;

VariantInit(&valueString);

if(value.vt == VT_BSTR)
valueString = value;
else
VariantChangeType(&valueString, &value, 0, VT_BSTR);

return valueString.bstrVal;
}

//VOString.h
#if !defined(AFX_VOSTRING_H__91406803_1D87_4DA9_A5A0_499A88AC4E86__INCLUDED_)
#define AFX_VOSTRING_H__91406803_1D87_4DA9_A5A0_499A88AC4E86__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CVOString
{
public:
CVOString(const CVOString& rSrc);
CVOString(LPCTSTR pcszValue = TEXT(""));
virtual ~CVOString();
operator LPCTSTR() { return (LPCTSTR)m_pBuffer; }
DWORD GetLength() { return m_dwLength; }
const CVOString& operator =(LPCTSTR pcszValue);
BOOL operator == (LPCTSTR pcszValue);
const CVOString& operator += (LPCTSTR pcszAppend);
protected:
BOOL SetMinBufferSize(DWORD dwChars);
DWORD m_dwLength;
DWORD m_dwBufferSize;
TCHAR* m_pBuffer;
};

#endif // !defined(AFX_VOSTRING_H__91406803_1D87_4DA9_A5A0_499A88AC4E86__INCLUDED_)

//VOString.cpp
//#include "stdafx.h"
#include "VOString.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CVOString::CVOString(LPCTSTR pcszValue)
{
m_pBuffer = NULL;
m_dwBufferSize = 0;

*this = pcszValue;
}

// Copy Constructor
CVOString::CVOString(const CVOString &rSrc)
{
m_pBuffer = NULL;
m_dwBufferSize = 0;

*this = rSrc.m_pBuffer;
}

CVOString::~CVOString()
{
if(m_pBuffer)
delete m_pBuffer;
}

const CVOString& CVOString::operator = (LPCTSTR pcszValue)
{

m_dwLength = _tcslen(pcszValue);

SetMinBufferSize(m_dwLength);
_tcscpy(m_pBuffer, pcszValue);
return *this;
}

BOOL CVOString::operator == (LPCTSTR pcszValue)
{
return(_tcscmp(pcszValue, m_pBuffer) == 0);
}

const CVOString& CVOString::operator += (LPCTSTR pcszAppend)
{
SetMinBufferSize(GetLength() + _tcslen(pcszAppend));

_tcscat(m_pBuffer, pcszAppend);
return *this;
}

BOOL CVOString::SetMinBufferSize(DWORD dwChars)
{
if(m_dwBufferSize < dwChars + 1)
{
TCHAR* pNewBuffer;
DWORD dwNewBufferSize = dwChars + 256;

pNewBuffer = new TCHAR[dwNewBufferSize];

  if(m_pBuffer)
  {
   memmove(pNewBuffer, m_pBuffer, m_dwBufferSize);
   delete m_pBuffer;
  }

m_pBuffer = pNewBuffer;
m_dwBufferSize = dwNewBufferSize;
}

return TRUE;
}

tiger 2007-01-09 12:03 发表评论

ADO数据库编程(C++)

tiger — Tue, 09 Jan 2007 03:48:00 GMT

一、在VC++中使用ADO编程
ADO实际上就是由一组Automation对象构成的组件，因此可以象使用其它任何Automation对象一样使用ADO。ADO中最重要的对象有三个：Connection、Command和Recordset，它们分别表示连接对象、命令对象和记录集对象。如果您熟悉使用MFC中的ODBC类（CDatabase、CRecordset)编程，那么学习ADO编程就十分容易了。
使用ADO编程时可以采用以下三种方法之一：
1、使用预处理指令#import
#import "C:\Program Files\Common Files\System\ADO\msado15.dll" no_namespace rename("EOF", "EndOfFile")
但要注意不能放在stdAfx.h文件的开头，而应该放在所有include指令的后面。否则在编译时会出错。
程序在编译过程中，VC++会读出msado15.dll中的类型库信息，自动产生两个该类型库的头文件和实现文件msado15.tlh和msado15.tli（在您的Debug或Release目录下）。在这两个文件里定义了ADO的所有对象和方法，以及一些枚举型的常量等。我们的程序只要直接调用这些方法就行了，与使用MFC中的COleDispatchDriver类调用Automation对象十分类似。

2、使用MFC中的CIDispatchDriver
就是通过读取msado15.dll中的类型库信息，建立一个COleDispatchDriver类的派生类，然后通过它调用ADO对象。

3、直接用COM提供的API
如使用如下代码：
CLSID clsid;
HRESULT hr = ::CLSIDFromProgID(L"ADODB.Connection", &clsid);
if(FAILED(hr))
{...}
::CoCreateInstance(clsid, NULL, CLSCTX_SERVER, IID_IDispatch, (void **)
&pDispatch);
if(FAILED(hr))
{...}
以上三种方法，第一和第二种类似，可能第一种好用一些，第三种编程可能最麻烦。但可能第三种方法也是效率最高的，程序的尺寸也最小，并且对ADO的控制能力也最强。
据微软资料介绍，第一种方法不支持方法调用中的默认参数，当然第二种方法也是这样，但第三种就不是这样了。采用第三种方法的水平也最高。当你需要绕过ADO而直接调用OLE DB底层的方法时，就一定要使用第三种方法了。
ADO编程的关键，就是熟练地运用ADO提供的各种对象(object)、方法(method)、属性(property)和容器（collection）。另外，如果是在MS SQL或Oracle等大型数据库上编程，还要能熟练使用SQL语言。

二、使用#import方法的编程步骤
这里建议您使用#import的方法，因为它易学、易用，代码也比较简洁。
1、添加#import指令
打开stdafx.h文件，将下列内容添加到所有的include指令之后：
#include //Include support for VC++ Extensions
#import "C:\Program Files\Common Files\System\ADO\msado15.dll" no_namespace rename("EOF", "adoEOF")
其中icrsint.h文件包含了VC++扩展的一些预处理指令、宏等的定义，用于COM编程时使用。

2、定义_ConnectionPtr型变量，并建立数据库连接
建立了与数据库服务器的连接后，才能进行其他有关数据库的访问和操作。ADO使用Connection对象来建立与数据库服务器的连接，所以它相当于MFC中的CDatabase类。和CDatabase类一样，调用Connection对象的Open方法即可建立与服务器的连接。
数据类型 _ConnectionPtr实际上就是由类模板_com_ptr_t而得到的一个具体的实例类，其定义可以到msado15.tlh、comdef.h 和comip.h这三个文件中找到。在msado15.tlh中有：
_COM_SMARTPTR_TYPEDEF(_Collection, __uuidof(_Collection));
经宏扩展后就得到了_ConnectionPtr类。_ConnectionPtr类封装了Connection对象的Idispatch接口指针，及一些必要的操作。我们就是通过这个指针来操纵Connection对象。类似地，后面用到的_CommandPtr和_RecordsetPtr类型也是这样得到的，它们分别表示命令对象指针和记录集对象的指针。
（1）、连接到MS SQL Server
注意连接字符串的格式，提供正确的连接字符串是成功连接到数据库服务器的第一步，有关连接字符串的详细信息参见微软MSDN Library光盘。
本例连接字符串中的server_name，database_name，user_name和password在编程时都应该替换成实际的内容。
_ConnectionPtr pMyConnect=NULL;
HRESULT hr=pMyConnect.CreateInstance(__uuidof(Connection)));
if(FAILED(hr))return;

_bstr_t strConnect="Provider=SQLOLEDB; Server=server_name;"
"Database=database_name; uid=user_name; pwd=password;";
//connecting to the database server now:
try{pMyConnect->Open(strConnect,"","",NULL);}
catch (_com_error &e)
{
::MessageBox(NULL,e.Description(),"警告",MB_OK | MB_ICONWARNING);
}

注意Connection对象的Open方法中的连接字符串参数必须是BSTR或_bstr_t类型。另外，本例是直接通过OLE DB Provider建立连接，所以无需建立数据源。

（2）、通过ODBC Driver连接到Database Server
连接字符串格式与直接用ODBC编程时的差不多：
_bstr_t strConnect="DSN=datasource_name; Database=database_name; uid=user_name; pwd=password;";
此时与ODBC编程一样，必须先建立数据源。

3、定义_RecordsetPtr型变量，并打开数据集
定义_RecordsetPtr型变量，然后通过它调用Recordset对象的Open方法，即可打开一个数据集。所以Recordset对象与MFC中的CRecordset类类似，它也有当前记录、当前记录指针的概念。如：
_RecordsetPtr m_pRecordset;
if(!FAILED(m_pRecordset.CreateInstance( __uuidof( Recordset )))
{
m_pDoc->m_initialized=FALSE;
return;
}

try{
m_pRecordset->Open(_variant_t("mytable"),
_variant_t((IDispatch *)pMyConnect,true), adOpenKeyset,
adLockOptimistic, adCmdTable);
}
catch (_com_error &e)
{
::MessageBox(NULL,"无法打开mytable表。","提示",
MB_OK | MB_ICONWARNING);
}
Recordset对象的Open方法非常重要，它的第一个参数可以是一个SQL语句、一个表的名字或一个命令对象等等；第二个参数就是前面建立的连接对象的指针。此外，用Connection和Command对象的Execute方法也能得到记录集，但是只读的。

4、读取当前记录的数据
我认为读取数据的最方便的方法如下：
try{
m_pRecordset->MoveFirst();
while(m_pRecordset->adoEOF==VARIANT_FALSE)
{
//Retrieve column's value:
CString sName=(char*)(_bstr_t)(m_pRecordset->Fields->GetItem
(_variant_t("name"))->Value);
short cAge=(short)(m_pRecordset->Fields->GetItem
(_variant_t("age"))->Value);
//Do something what you want to do:
......
m_pRecordset->MoveNext();
}
}//try
catch (_com_error &e)
{
CString str=(char*)e.Description();
::MessageBox(NULL,str+"\n又出毛病了。","提示",
MB_OK | MB_ICONWARNING);
}

本例中的name和age都是字段名，读取的字段值分别保存在sName和cAge变量内。例中的Fields是Recordset对象的容器，GetItem方法返回的是Field对象，而Value则是Field对象的一个属性（即该字段的值）。通过此例，应掌握操纵对象属性的方法。例如，要获得Field 对象的Value属性的值可以直接用属性名Value来引用它（如上例），但也可以调用Get方法，例如：
CString sName=(char*)(_bstr_t)(m_pRecordset->Fields->GetItem
(_variant_t("name"))->GetValue());
从此例还可以看到，判断是否到达记录集的末尾，使用记录集的adoEOF属性，其值若为真即到了结尾，反之则未到。判断是否到达记录集开头，则可用BOF属性。
另外，读取数据还有一个方法，就是定义一个绑定的类，然后通过绑定的变量得到字段值（详见后面的介绍）。

5、修改数据
方法一：
try{
m_pRecordset->MoveFirst();
while(m_pRecordset->adoEOF==VARIANT_FALSE)
{
m_pRecordset->Fields->GetItem
(_variant_t("姓名"))->Value=_bstr_t("赵薇");
......
m_pRecordset->Update();

m_pRecordset->MoveNext();
}
}//try
改变了Value属性的值，即改变了字段的值。
方法二：
m_pRecordset->Fields->GetItem
(_variant_t("姓名"))->PutValue(_bstr_t("赵薇"));
方法三：就是用定义绑定类的方法（详见后面的介绍）。

6、添加记录
新记录添加成功后，即自动成为当前记录。AddNew方法有两种形式，一个含有参数，而另一个则不带参数。
方法一（不带参数）：
// Add new record into this table:
try{
if(!m_pRecordset->Supports(adAddNew)) return;

m_pRecordset->AddNew();
m_pRecordset->Fields->GetItem
(_variant_t("姓名"))->Value=_bstr_t("赵薇");
m_pRecordset->Fields->GetItem
(_variant_t("性别"))->Value=_bstr_t("女");
m_pRecordset->Fields->GetItem
(_variant_t("age"))->Value=_variant_t((short)20);
m_pRecordset->Fields->GetItem
(_variant_t("marry"))->Value=_bstr_t("未婚");
m_pRecordset->Update();
}//try
catch (_com_error &e)
{
::MessageBox(NULL, "又出毛病了。","提示",MB_OK | MB_ICONWARNING);
}
这种方法弄完了还要调用Update()。
方法二（带参数）：
_variant_t varName[4],narValue[4];
varName[0] = L"姓名";
varName[1] = L"性别";
varName[2] = L"age";
varName[3] = L"marry";
narValue[0]=_bstr_t("赵薇");
narValue[1]=_bstr_t("女");
narValue[2]=_variant_t((short)20);
narValue[3]=_bstr_t("未婚");

const int nCrit = sizeof varName / sizeof varName[0];
// Create SafeArray Bounds and initialize the array
SAFEARRAYBOUND rgsaName[1],rgsaValue[1];
rgsaName[0].lLbound = 0;
rgsaName[0].cElements = nCrit;
SAFEARRAY *psaName = SafeArrayCreate( VT_VARIANT, 1, rgsaName );
rgsaValue[0].lLbound = 0;
rgsaValue[0].cElements = nCrit;
SAFEARRAY *psaValue = SafeArrayCreate( VT_VARIANT, 1, rgsaValue );
// Set the values for each element of the array
HRESULT hr1=S_OK.hr2=S_OK;
for( long i = 0 ; i < nCrit && SUCCEEDED( hr1 ) && SUCCEEDED( hr2 );i++)
{
hr1=SafeArrayPutElement(psaName, &i,&varName[i]);
hr2=SafeArrayPutElement(psaValue, &i,&narValue[i]); }

// Initialize and fill the SafeArray
VARIANT vsaName,vsaValue;
vsaName.vt = VT_VARIANT | VT_ARRAY;
vsaValue.vt = VT_VARIANT | VT_ARRAY;
V_ARRAY(&vsaName) = psaName;//&vsaName->parray=psaName;
//see definition in oleauto.h file.
V_ARRAY(&vsaValue) = psaValue;

// Add a new record:
m_pRecordset->AddNew(vsaName,vsaValue);
这种方法不需要调用Update，因为添加后，ADO会自动调用它。此方法主要是使用SafeArray挺麻烦。
方法三：就是用定义绑定类的方法（详见后面的介绍）。

7、删除记录
调用Recordset的Delete方法就行了，删除的是当前记录。要了解Delete的其它用法请查阅参考文献。
try{
m_pRecordset->MoveFirst();
while(m_pRecordset->adoEOF==VARIANT_FALSE)
{
CString sName=(char*)(_bstr_t)(m_pRecordset->Fields->GetItem
(_variant_t("姓名"))->Value);
if(::MessageBox(NULL,"姓名="+sName+"\n删除她吗？",
"提示",MB_YESNO | MB_ICONWARNING)==IDYES)
{
m_pRecordset->Delete(adAffectCurrent);
m_pRecordset->Update();
}
m_pRecordset->MoveNext();
}
}//try
catch (_com_error &e)
{
::MessageBox(NULL,"又出毛病了。","提示",MB_OK | MB_ICONWARNING);
}

8、使用带参数的命令
Command对象所代表的就是一个Provider能够理解的命令，如SQL语句等。使用Command对象的关键就是把表示命令的语句设置到CommandText属性中，然后调用Command对象的Execute方法就行了。一般情况下在命令中无需使用参数，但有时使用参数，可以增加其灵活性和效率。
(1). 建立连接、命令对象和记录集对象
本例中表示命令的语句就是一个SQL语句（SELECT语句）。SELECT语句中的问号?就代表参数，如果要多个参数，就多放几个问号，每个问号代表一个参数。
_ConnectionPtr Conn1;
_CommandPtr Cmd1;
ParametersPtr *Params1 = NULL; // Not an instance of a smart pointer.
_ParameterPtr Param1;
_RecordsetPtr Rs1;

try
{
// Create Connection Object (1.5 Version)
Conn1.CreateInstance( __uuidof( Connection ) );
Conn1->ConnectionString = bstrConnect;
Conn1->Open( bstrEmpty, bstrEmpty, bstrEmpty, -1 );
// Create Command Object
Cmd1.CreateInstance( __uuidof( Command ) );
Cmd1->ActiveConnection = Conn1;
Cmd1->CommandText = _bstr_t("SELECT * FROM mytable WHERE age< ?");
}//try
要注意命令对象必须与连接对象关联起来才能起作用，本例中将命令对象的ActiveConnection属性设置为连接对象的指针，即为此目的：
Cmd1->ActiveConnection = Conn1;

(2). 创建参数对象，并给参数赋值
// Create Parameter Object
Param1 = Cmd1->CreateParameter( _bstr_t(bstrEmpty),
adInteger,
adParamInput,
-1,
_variant_t( (long) 5) );
Param1->Value = _variant_t( (long) 5 );
Cmd1->Parameters->Append( Param1 );
用命令对象的方法来创建一个参数对象，其中的长度参数（第三个）如果是固定长度的类型，就填-1，如果是字符串等可变长度的就填其实际长度。Parameters是命令对象的一个容器，它的Append方法就是把创建的参数对象追加到该容器里。Append进去的参数按先后顺序与SQL语句中的问号从左至右一一对应。

(3). 执行命令打开记录集
// Open Recordset Object
Rs1 = Cmd1->Execute( &vtEmpty, &vtEmpty2, adCmdText );
但要注意，用Command和Connection对象的Execute方法得到的Recordset是只读的。因为在打开Recordset之前，我们无法设置它的LockType属性（其默认值为只读）。而在打开之后设置LockType不起作用。
我发现用上述方法得到记录集Rs1后，不但Rs1中的记录无法修改，即使直接用SQL语句修改同一表中任何记录都不行。
要想能修改数据，还是要用Recordset自己的Open方法才行，如：
try{
m_pRecordset->Open((IDispatch *) Cmd1, vtMissing,
adOpenStatic, adLockOptimistic, adCmdUnspecified);
}
catch (_com_error &e)
{
::MessageBox(NULL,"mytable表不存在。","提示",MB_OK | MB_ICONWARNING);
}
Recordset对象的Open方法真是太好了，其第一个参数可以是SQL语句、表名字、命令对象指针等等。

9、响应ADO的通知事件
通知事件就是当某个特定事件发生时，由Provider通知客户程序，换句话说，就是由Provider调用客户程序中的一个特定的方法（即事件的处理函数）。所以为了响应一个事件，最关键的就是要实现事件的处理函数。
(1). 从ConnectionEventsVt接口派生出一个类
为了响应_Connection的通知事件，应该从ConnectionEventsVt接口派生出一个类：
class CConnEvent : public ConnectionEventsVt
{
private:
ULONG m_cRef;
public:
CConnEvent() { m_cRef = 0; };
~CConnEvent() {};

STDMETHODIMP QueryInterface(REFIID riid, void ** ppv);
STDMETHODIMP_(ULONG) AddRef(void);
STDMETHODIMP_(ULONG) Release(void);
STDMETHODIMP raw_InfoMessage(
struct Error *pError,
EventStatusEnum *adStatus,
struct _Connection *pConnection);
STDMETHODIMP raw_BeginTransComplete(
LONG TransactionLevel,
struct Error *pError,
EventStatusEnum *adStatus,
struct _Connection *pConnection);
......
};

(2). 实现每一个事件的处理函数(凡是带raw_前缀的方法都把它实现了)：
STDMETHODIMP CConnEvent::raw_InfoMessage(
struct Error *pError,
EventStatusEnum *adStatus,
struct _Connection *pConnection)
{
*adStatus = adStatusUnwantedEvent;
return S_OK;
};

有些方法虽然你并不需要，但也必须实现它，只需简单地返回一个S_OK即可。但如果要避免经常被调用，还应在其中将adStatus参数设置为adStatusUnwantedEvent，则在本次调用后，以后就不会被调用了。
另外还必须实现QueryInterface, AddRef, 和Release三个方法:
STDMETHODIMP CConnEvent::QueryInterface(REFIID riid, void ** ppv)
{
*ppv = NULL;
if (riid == __uuidof(IUnknown) ||
riid == __uuidof(ConnectionEventsVt)) *ppv = this;
if (*ppv == NULL)
return ResultFromScode(E_NOINTERFACE);
AddRef();
return NOERROR;
}
STDMETHODIMP_(ULONG) CConnEvent::AddRef() { return ++m_cRef; };
STDMETHODIMP_(ULONG) CConnEvent::Release()
{
if (0 != --m_cRef) return m_cRef;
delete this;
return 0;
}

(3). 开始响应通知事件
// Start using the Connection events
IConnectionPointContainer *pCPC = NULL;
IConnectionPoint *pCP = NULL;

hr = pConn.CreateInstance(__uuidof(Connection));
if (FAILED(hr)) return;

hr = pConn->QueryInterface(__uuidof(IConnectionPointContainer),
(void **)&pCPC);
if (FAILED(hr)) return;
hr = pCPC->FindConnectionPoint(__uuidof(ConnectionEvents), &pCP);
pCPC->Release();
if (FAILED(hr)) return;

pConnEvent = new CConnEvent();
hr = pConnEvent->QueryInterface(__uuidof(IUnknown), (void **) &pUnk);
if (FAILED(hr)) return rc;
hr = pCP->Advise(pUnk, &dwConnEvt);
pCP->Release();
if (FAILED(hr)) return;

pConn->Open("dsn=Pubs;", "sa", "", adConnectUnspecified);
也就是说在连接(Open)之前就做这些事。

(4). 停止响应通知事件
pConn->Close();
// Stop using the Connection events
hr = pConn->QueryInterface(__uuidof(IConnectionPointContainer),
(void **) &pCPC);
if (FAILED(hr)) return;
hr = pCPC->FindConnectionPoint(__uuidof(ConnectionEvents), &pCP);
pCPC->Release();
if (FAILED(hr)) return rc;
hr = pCP->Unadvise( dwConnEvt );
pCP->Release();
if (FAILED(hr)) return;
在连接关闭之后做这件事。

10、邦定数据
定义一个绑定类，将其成员变量绑定到一个指定的记录集，以方便于访问记录集的字段值。
(1). 从CADORecordBinding派生出一个类：
class CCustomRs : public CADORecordBinding
{
BEGIN_ADO_BINDING(CCustomRs)
ADO_VARIABLE_LENGTH_ENTRY2(3, adVarChar, m_szau_fname,
sizeof(m_szau_fname), lau_fnameStatus, false)
ADO_VARIABLE_LENGTH_ENTRY2(2, adVarChar, m_szau_lname,
sizeof(m_szau_lname), lau_lnameStatus, false)
ADO_VARIABLE_LENGTH_ENTRY2(4, adVarChar, m_szphone,
sizeof(m_szphone), lphoneStatus, true)
END_ADO_BINDING()

public:
CHAR m_szau_fname[22];
ULONG lau_fnameStatus;
CHAR m_szau_lname[42];
ULONG lau_lnameStatus;
CHAR m_szphone[14];
ULONG lphoneStatus;
};
其中将要绑定的字段与变量名用BEGIN_ADO_BINDING宏关联起来。每个字段对应于两个变量，一个存放字段的值，另一个存放字段的状态。字段用从1开始的序号表示，如1，2，3等等。
特别要注意的是：如果要绑定的字段是字符串类型，则对应的字符数组的元素个数一定要比字段长度大2（比如m_szau_fname[22]，其绑定的字段au_fname的长度实际是20），不这样绑定就会失败。我分析多出的2可能是为了存放字符串结尾的空字符null和BSTR字符串开头的一个字（表示BSTR的长度）。这个问题对于初学者来说可能是一个意想不到的问题。
CADORecordBinding类的定义在icrsint.h文件里，内容是：
class CADORecordBinding
{
public:
STDMETHOD_(const ADO_BINDING_ENTRY*, GetADOBindingEntries) (VOID) PURE;
};

BEGIN_ADO_BINDING宏的定义也在icrsint.h文件里，内容是：
#define BEGIN_ADO_BINDING(cls) public: typedef cls ADORowClass; const ADO_BINDING_ENTRY* STDMETHODCALLTYPE GetADOBindingEntries() { static const ADO_BINDING_ENTRY rgADOBindingEntries[] = {

ADO_VARIABLE_LENGTH_ENTRY2宏的定义也在icrsint.h文件里：
#define ADO_VARIABLE_LENGTH_ENTRY2(Ordinal, DataType, Buffer, Size, Status, Modify) {Ordinal, DataType, 0, 0, Size, offsetof(ADORowClass, Buffer), offsetof(ADORowClass, Status), 0, classoffset(CADORecordBinding, ADORowClass), Modify},

#define END_ADO_BINDING宏的定义也在icrsint.h文件里：
#define END_ADO_BINDING() {0, adEmpty, 0, 0, 0, 0, 0, 0, 0, FALSE}}; return rgADOBindingEntries;}

(2). 绑定
_RecordsetPtr Rs1;
IADORecordBinding *picRs=NULL;
CCustomRs rs;
......
Rs1->QueryInterface(__uuidof(IADORecordBinding),
(LPVOID*)&picRs));
picRs->BindToRecordset(&rs);
派生出的类必须通过IADORecordBinding接口才能绑定，调用它的BindToRecordset方法就行了。

(3). rs中的变量即是当前记录字段的值
//Set sort and filter condition:
// Step 4: Manipulate the data
Rs1->Fields->GetItem("au_lname")->Properties->GetItem("Optimize")->Value = true;
Rs1->Sort = "au_lname ASC";
Rs1->Filter = "phone LIKE '415 5*'";

Rs1->MoveFirst();
while (VARIANT_FALSE == Rs1->EndOfFile)
{
printf("Name: %s\t %s\tPhone: %s\n",
(rs.lau_fnameStatus == adFldOK ? rs.m_szau_fname : ""),
(rs.lau_lnameStatus == adFldOK ? rs.m_szau_lname : ""),
(rs.lphoneStatus == adFldOK ? rs.m_szphone : ""));
if (rs.lphoneStatus == adFldOK)
strcpy(rs.m_szphone, "777");
TESTHR(picRs->Update(&rs)); // Add change to the batch
Rs1->MoveNext();
}
Rs1->Filter = (long) adFilterNone;
......
if (picRs) picRs->Release();
Rs1->Close();
pConn->Close();
只要字段的状态是adFldOK，就可以访问。如果修改了字段，不要忘了先调用picRs的Update（注意不是Recordset的Update），然后才关闭，也不要忘了释放picRs（即picRs->Release();）。

(4). 此时还可以用IADORecordBinding接口添加新纪录
if(FAILED(picRs->AddNew(&rs)))
......
11. 访问长数据
在Microsoft SQL中的长数据包括text、image等这样长类型的数据，作为二进制字节来对待。
可以用Field对象的GetChunk和AppendChunk方法来访问。每次可以读出或写入全部数据的一部分，它会记住上次访问的位置。但是如果中间访问了别的字段后，就又得从头来了。
请看下面的例子：
//写入一张照片到数据库：
VARIANT varChunk;
SAFEARRAY *psa;
SAFEARRAYBOUND rgsabound[1];

//VT_ARRAY | VT_UI1
CFile f("h:\\aaa.jpg",CFile::modeRead);
BYTE bVal[ChunkSize+1];
UINT uIsRead=0;
//Create a safe array to store the array of BYTES
while(1)
{
uIsRead=f.Read(bVal,ChunkSize);
if(uIsRead==0)break;
rgsabound[0].cElements =uIsRead;
rgsabound[0].lLbound = 0;
psa = SafeArrayCreate(VT_UI1,1,rgsabound);
for(long index=0;index{
if(FAILED(SafeArrayPutElement(psa,&index,&bVal[index])))
::MessageBox(NULL,"啊，又出毛病了。","提示",MB_OK | MB_ICONWARNING);
}
varChunk.vt = VT_ARRAY|VT_UI1;
varChunk.parray = psa;
try{
m_pRecordset->Fields->GetItem("photo")->AppendChunk(varChunk);
}
catch (_com_error &e)
{
CString str=(char*)e.Description();
::MessageBox(NULL,str+"\n又出毛病了。","提示",MB_OK | MB_ICONWARNING);
}
::VariantClear(&varChunk);
::SafeArrayDestroyData( psa);
if(uIsRead}//while(1)
f.Close();

//从数据库读一张照片：
CFile f;
f.Open("h:\\bbb.jpg",CFile::modeWrite|CFile::modeCreate);
long lPhotoSize = m_pRecordset->Fields->Item["photo"]->ActualSize;
long lIsRead=0;

_variant_t varChunk;
BYTE buf[ChunkSize];
while(lPhotoSize>0)
{
lIsRead=lPhotoSize>=ChunkSize? ChunkSize:lPhotoSize;
varChunk = m_pRecordset->Fields->
Item["photo"]->GetChunk(lIsRead);
for(long index=0;index{
::SafeArrayGetElement(varChunk.parray,&index,buf+index);
}
f.Write(buf,lIsRead);
lPhotoSize-=lIsRead;
}//while()
f.Close();

12. 使用SafeArray问题
学会使用SafeArray也是很重要的，因为在ADO编程中经常要用。它的主要目的是用于automation中的数组型参数的传递。因为在网络环境中，数组是不能直接传递的，而必须将其包装成SafeArray。实质上SafeArray就是将通常的数组增加一个描述符，说明其维数、长度、边界、元素类型等信息。SafeArray也并不单独使用，而是将其再包装到VARIANT类型的变量中，然后才作为参数传送出去。在VARIANT的vt成员的值如果包含VT_ARRAY|...,那么它所封装的就是一个SafeArray，它的parray成员即是指向SafeArray的指针。SafeArray中元素的类型可以是VARIANT能封装的任何类型，包括VARIANT类型本身。
使用SafeArray的具体步骤：
方法一：
包装一个SafeArray：
(1). 定义变量，如：
VARIANT varChunk;
SAFEARRAY *psa;
SAFEARRAYBOUND rgsabound[1];

(2). 创建SafeArray描述符：
uIsRead=f.Read(bVal,ChunkSize);//read array from a file.
if(uIsRead==0)break;
rgsabound[0].cElements =uIsRead;
rgsabound[0].lLbound = 0;
psa = SafeArrayCreate(VT_UI1,1,rgsabound);

(3). 放置数据元素到SafeArray：
for(long index=0;index{
if(FAILED(SafeArrayPutElement(psa,&index,&bVal[index])))
::MessageBox(NULL,"出毛病了。","提示",MB_OK | MB_ICONWARNING);
}
一个一个地放，挺麻烦的。
(4). 封装到VARIANT内：
varChunk.vt = VT_ARRAY|VT_UI1;
varChunk.parray = psa;
这样就可以将varChunk作为参数传送出去了。

读取SafeArray中的数据的步骤：
(1). 用SafeArrayGetElement一个一个地读
BYTE buf[lIsRead];
for(long index=0;index{
::SafeArrayGetElement(varChunk.parray,&index,buf+index);
}
就读到缓冲区buf里了。

方法二：
使用SafeArrayAccessData直接读写SafeArray的缓冲区：
(1). 读缓冲区：
BYTE *buf;
SafeArrayAccessData(varChunk.parray, (void **)&buf);
f.Write(buf,lIsRead);
SafeArrayUnaccessData(varChunk.parray);

(2). 写缓冲区：
BYTE *buf;
::SafeArrayAccessData(psa, (void **)&buf);
for(long index=0;index{
buf[index]=bVal[index];
}
::SafeArrayUnaccessData(psa);

varChunk.vt = VT_ARRAY|VT_UI1;
varChunk.parray = psa;

这种方法读写SafeArray都可以，它直接操纵SafeArray的数据缓冲区，比用SafeArrayGetElement和SafeArrayPutElement速度快。特别适合于读取数据。但用完之后不要忘了调用::SafeArrayUnaccessData(psa)，否则会出错的。

13. 使用书签( bookmark )
书签可以唯一标识记录集中的一个记录，用于快速地将当前记录移回到已访问过的记录，以及进行过滤等等。Provider会自动为记录集中的每一条记录产生一个书签，我们只需要使用它就行了。我们不能试图显示、修改或比较书签。ADO用记录集的Bookmark属性表示当前记录的书签。
用法步骤：
(1). 建立一个VARIANT类型的变量
_variant_t VarBookmark;

(2). 将当前记录的书签值存入该变量
也就是记录集的Bookmark属性的当前值。
VarBookmark = rst->Bookmark;

(3). 返回到先前的记录
将保存的书签值设置到记录集的书签属性中：
// Check for whether bookmark set for a record
if (VarBookmark.vt == VT_EMPTY)
printf("No Bookmark set!\n");
else
rst->Bookmark = VarBookmark;
设置完后，当前记录即会移动到该书签指向的记录。

14、设置过滤条件
Recordset对象的Filter属性表示了当前的过滤条件。它的值可以是以AND或OR连接起来的条件表达式（不含WHERE关键字）、由书签组成的数组或ADO提供的FilterGroupEnum枚举值。为Filter属性设置新值后Recordset的当前记录指针会自动移动到满足过滤条件的第一个记录。例如：
rst->Filter = _bstr_t ("姓名='赵薇' AND 性别=’女’");
在使用条件表达式时应注意下列问题：
（1）、可以用圆括号组成复杂的表达式
例如：
rst->Filter = _bstr_t ("(姓名='赵薇' AND 性别=’女’) OR AGE<25");
但是微软不允许在括号内用OR，然后在括号外用AND，例如：
rst->Filter = _bstr_t ("(姓名='赵薇' OR 性别=’女’) AND AGE<25");
必须修改为：
rst->Filter = _bstr_t ("(姓名='赵薇' AND AGE<25) OR (性别=’女’ AND AGE<25)");

（2）、表达式中的比较运算符可以是LIKE
LIKE后被比较的是一个含有通配符*的字符串，星号表示若干个任意的字符。
字符串的首部和尾部可以同时带星号*
rst->Filter = _bstr_t ("姓名 LIKE '*赵*' ");
也可以只是尾部带星号：
rst->Filter = _bstr_t ("姓名 LIKE '赵*' ");
Filter属性值的类型是Variant，如果过滤条件是由书签组成的数组，则需将该数组转换为SafeArray，然后再封装到一个VARIANT或_variant_t型的变量中，再赋给Filter属性。

15、索引与排序
（1）、建立索引
当以某个字段为关键字用Find方法查找时，为了加快速度可以以该字段为关键字在记录集内部临时建立索引。只要将该字段的Optimize属性设置为true即可，例如：
pRst->Fields->GetItem("姓名")->Properties->
GetItem("Optimize")->PutValue("True");
pRst->Find("姓名 = '赵薇'",1,adSearchForward);
......
pRst->Fields->GetItem("姓名")->Properties->
GetItem("Optimize")->PutValue("False");
pRst->Close();
说明：Optimize属性是由Provider提供的属性（在ADO中称为动态属性），ADO本身没有此属性。

（2）、排序
要排序也很简单，只要把要排序的关键字列表设置到Recordset对象的Sort属性里即可，例如：
pRstAuthors->CursorLocation = adUseClient;
pRstAuthors->Open("SELECT * FROM mytable",
_variant_t((IDispatch *) pConnection),
adOpenStatic, adLockReadOnly, adCmdText);
......
pRst->Sort = "姓名 DESC, 年龄 ASC";
关键字（即字段名）之间用逗号隔开，如果要以某关键字降序排序，则应在该关键字后加一空格，再加DESC（如上例）。升序时ASC加不加无所谓。本操作是利用索引进行的，并未进行物理排序，所以效率较高。
但要注意，在打开记录集之前必须将记录集的CursorLocation属性设置为adUseClient，如上例所示。Sort属性值在需要时随时可以修改。

16、事务处理
ADO中的事务处理也很简单，只需分别在适当的位置调用Connection对象的三个方法即可，这三个方法是：
（1）、在事务开始时调用
pCnn->BeginTrans();

（2）、在事务结束并成功时调用

pCnn->CommitTrans ();
（3）、在事务结束并失败时调用
pCnn->RollbackTrans ();
在使用事务处理时，应尽量减小事务的范围，即减小从事务开始到结束（提交或回滚）之间的时间间隔，以便提高系统效率。需要时也可在调用BeginTrans()方法之前，先设置Connection对象的IsolationLevel属性值，详细内容参见MSDN中有关ADO的技术资料。

三、使用ADO编程常见问题解答
以下均是针对MS SQL 7.0编程时所遇问题进行讨论。
1、连接失败可能原因
Enterprise Managemer内，打开将服务器的属性对话框，在Security选项卡中，有一个选项Authentication。
如果该选项是Windows NT only，则你的程序所用的连接字符串就一定要包含Trusted_Connection参数，并且其值必须为yes，如：
"Provider=SQLOLEDB;Server=888;Trusted_Connection=yes"
";Database=master;uid=lad;";
如果不按上述操作，程序运行时连接必然失败。
如果Authentication选项是SQL Server and Windows NT，则你的程序所用的连接字符串可以不包含Trusted_Connection参数，如：
"Provider=SQLOLEDB;Server=888;Database=master;uid=lad;pwd=111;";
因为ADO给该参数取的默认值就是no，所以可以省略。我认为还是取默认值比较安全一些。

2、改变当前数据库的方法
使用Tansct-SQL中的USE语句即可。

3、如何判断一个数据库是否存在
(1)、可打开master数据库中一个叫做SCHEMATA的视图，其内容列出了该服务器上所有的数据库名称。

(2) 、更简便的方法是使用USE语句，成功了就存在；不成功，就不存在。例如：
try{
m_pConnect->Execute ( _bstr_t("USE INSURANCE_2002"),NULL,
adCmdText|adExecuteNoRecords );
}
catch (_com_error &e)
{
blSuccess=FALSE;
CString str="数据库INSURANCE_2002不存在！\n";
str+=e.Description();
::MessageBox(NULL,str,"警告",MB_OK | MB_ICONWARNING);
}

4、判断一个表是否存在
（1）、同样判断一个表是否存在，也可以用是否成功地打开它来判断，十分方便，例如：
try{
m_pRecordset->Open(_variant_t("mytable"),
_variant_t((IDispatch *)m_pConnection,true), adOpenKeyset,
adLockOptimistic, adCmdTable);
}
catch (_com_error &e)
{
::MessageBox(NULL,"该表不存在。","提示",MB_OK | MB_ICONWARNING);
}

(2)、要不然可以采用麻烦一点的办法，就是在MS-SQL服务器上的每个数据库中都有一个名为sysobjects的表，查看此表的内容即知指定的表是否在该数据库中。

(3)、同样，每个数据库中都有一个名为TABLES的视图(View)，查看此视图的内容即知指定的表是否在该数据库中。

5、类型转换问题
（1）、类型VARIANT_BOOL
类型VARIANT_BOOL等价于short类型。The VARIANT_BOOL is equivalent to short. see it's definition below:
typdef short VARIANT_BOOL

（2）、_com_ptr_t类的类型转换
_ConnectionPtr可以自动转换成IDspatch*类型，这是因为_ConnectionPtr实际上是_com_ptr_t类的一个实例，而这个类有此类型转换函数。
同理，_RecordsetPtr和_CommandPtr也都可以这样转换。

（3）、_bstr_t和_variant_t类
在ADO编程时，_bstr_t和_variant_t这两个类很有用，省去了许多BSTR和VARIANT类型转换的麻烦。

6、打开记录集时的问题
在打开记录集时，在调用Recordset的Open方法时，其最后一个参数里一定不能包含adAsyncExecute，否则将因为是异步操作，在读取数据时无法读到数据。

7、异常处理问题
对所有调用ADO的语句一定要用try和catch语句捕捉异常，否则在发生异常时，程序会异常退出。

8、使用SafeArray问题
在初学使用中，我曾遇到一个伤脑筋的问题，一定要注意：
在定义了SAFEARRAY的指针后，如果打算重复使用多次，则在中间可以调用::SafeArrayDestroyData释放数据，但决不能调用::SafeArrayDestroyDescriptor，否则必然出错，即使调用SafeArrayCreate也不行。例如：
SAFEARRAY *psa;
......
//When the data are no longer to be used:
::SafeArrayDestroyData( psa);
我分析在定义psa指针时，一个SAFEARRAY的实例（也就是SAFEARRAY描述符）也同时被自动建立了。但是只要一调用::SafeArrayDestroyDescriptor，描述符就被销毁了。
所以我认为::SafeArrayDestroyDescriptor可以根本就不调用，即使调用也必须在最后调用。

9、重复使用命令对象问题
一个命令对象如果要重复使用多次（尤其是带参数的命令），则在第一次执行之前，应将它的Prepared属性设置为TRUE。这样会使第一次执行减慢，但却可以使以后的执行全部加快。

10、绑定字符串型字段问题
如果要绑定的字段是字符串类型，则对应的字符数组的元素个数一定要比字段长度大2（比如m_szau_fname[22]，其绑定的字段au_fname的长度实际是20），不这样绑定就会失败。

11、使用AppendChunk的问题
当用AddNew方法刚刚向记录集内添加一个新记录之后，不能首先向一个长数据字段（image类型）写入数据，必须先向其他字段写入过数据之后，才能调用AppendChunk写该字段，否则出错。也就是说，AppendChunk不能紧接在AddNew之后。另外，写入其他字段后还必须紧接着调用AppendChunk，而不能调用记录集的Update方法后，才调用AppendChunk，否则调用AppendChunk时也会出错。换句话说，就是必须AppendChunk在前，Update在后。因而这个时候就不能使用带参数的AddNew了，因为带参数的AddNew会自动调用记录集的Update，所以AppendChunk就跑到Update的后面了，就只有出错了！因此，这时应该用不带参数的AddNew。
我推测这可能是MS SQL 7.0的问题，在MS SQL 2000中则不存在这些问题，但是AppendChunk仍然不能在Update之后。

四、小结
一般情况下，Connection和Command的Execute用于执行不产生记录集的命令，而Recordset的Open用于产生一个记录集，当然也不是绝对的。特别Command主要是用于执行参数化的命令，可以直接由Command对象执行，也可以将Command对象传递给Recordset的Open。

tiger 2007-01-09 11:48 发表评论