自动生成的工程文件配置的PreprocessorDefinitions 是 WIN32;_DEBUG;_WINDOWS
需要改成 PreprocessorDefinitions="WIN32;_DEBUG;_WINDOWS;UNICODE;_WIN32_WINNT=0x0501"
有的项目编译不了是因为 CharacterSet 的问题
六年前，我刚热恋“面向对象”（Object-Oriented）时，一口气记住了近十个定义。六年后，我从几十万行程序中滚爬出来准备写点心得体会时，却无法解释什么是“面向对象”，就象说不清楚什么是数学那样。软件工程中的时髦术语“面向对象分析”和“面向对象设计”，通常是针对“需求分析”和“系统设计”环节的。“面向对象”有几大学派，就象如来佛、上帝和真主用各自的方式定义了这个世界，并留下一堆经书来解释这个世界。
有些学者建议这样找“对象”：分析一个句子的语法，找出名词和动词，名词就是对象，动词则是对象的方法（即函数）。
当年国民党的文人为了对抗毛泽东的《沁园春·雪》，特意请清朝遗老们写了一些对仗工整的诗，请蒋介石过目。老蒋看了气得大骂：“娘希匹，全都有一股棺材里腐尸的气味。”我看了几千页的软件工程资料，终于发现自己有些“弱智”，无法理解“面向对象”的理论，同时醒悟到“编程是硬道理。”
面向对象程序设计语言很多，如Smalltalk、Ada、Eiffel、Object Pascal、Visual Basic、C++等等。C++语言最讨人喜欢，因为它兼容C 语言，并且具备C 语言的性能。近几年，一种叫Java 的纯面向对象语言红极一时，不少人叫喊着要用Java 革C++的命。我认为Java 好比是C++的外甥，虽然不是直接遗传的，但也几分象样。外甥在舅舅身上玩耍时洒了一泡尿，俩人不该为此而争吵。
关于C++程序设计的书藉非常多，本章不讲C++的语法，只讲一些小小的编程道理。如果我能早几年明白这些小道理，就可以大大改善数十万行程序的质量了。
1. C++面向对象程序设计的重要概念
早期革命影片里有这样一个角色，他说：“我是党代表，我代表党，我就是党。”后来他给同志们带来了灾难。
会用C++的程序员一定懂得面向对象程序设计吗？
不会用C++的程序员一定不懂得面向对象程序设计吗？
两者都未必。就象坏蛋入党后未必能成为好人，好人不入党未必变成坏蛋那样。
我不怕触犯众怒地说句大话：“C++没有高手，C 语言才有高手。”在用C 和C++编程8年之后，我深深地遗憾自己不是C 语言的高手，更遗憾没有人点拨我如何进行面向对象程序设计。我和很多C++程序员一样，在享用到C++语法的好处时便以为自己已经明白了面向对象程序设计。就象挤掉牙膏卖牙膏皮那样，真是暴殄天物呀。
人们不懂拼音也会讲普通话，如果懂得拼音则会把普通话讲得更好。不懂面向对象程序设计也可以用C++编程，如果懂得面向对象程序设计则会把C++程序编得更好。本节讲述三个非常基础的概念：“类与对象”、“继承与组合”、“虚函数与多态”。理解这些概念，有助于提高程序的质量，特别是提高“可复用性”与“可扩充性”。
1.1 类与对象
对象（Object）是类（Class）的一个实例（Instance）。如果将对象比作房子，那么类就是房子的设计图纸。所以面向对象程序设计的重点是类的设计，而不是对象的设计。类可以将数据和函数封装在一起，其中函数表示了类的行为（或称服务）。类提供关键字public、protected 和private 用于声明哪些数据和函数是公有的、受保护的或者是私有的。
这样可以达到信息隐藏的目的，即让类仅仅公开必须要让外界知道的内容，而隐藏其它一切内容。我们不可以滥用类的封装功能，不要把它当成火锅，什么东西都往里扔。
类的设计是以数据为中心，还是以行为为中心？
主张“以数据为中心”的那一派人关注类的内部数据结构，他们习惯上将private 类型的数据写在前面，而将public 类型的函数写在后面，如表8.1(a)所示。
主张“以行为为中心”的那一派人关注类应该提供什么样的服务和接口，他们习惯上将public 类型的函数写在前面，而将private 类型的数据写在后面，如表8.1(b)所示。
很多C++教课书主张在设计类时“以数据为中心”。我坚持并且建议读者在设计类时“以行为为中心”，即首先考虑类应该提供什么样的函数。Microsoft 公司的COM 规范的核心是接口设计，COM 的接口就相当于类的公有函数[Rogerson 1999]。在程序设计方面，咱们不要怀疑Microsoft 公司的风格。
设计孤立的类是比较容易的，难的是正确设计基类及其派生类。因为有些程序员搞不清楚“继承”（Inheritance）、“组合”（Composition）、“多态”（ Polymorphism）这些概念。
1.2 继承与组合
如果A 是基类，B 是A 的派生类，那么B 将继承A 的数据和函数。示例程序如下：
class A
{
public:
void Func1(void);
void Func2(void);
};
class B : public A
{
public:
void Func3(void);
void Func4(void);
};
// Example
main()
{
B b; // B的一个对象
b.Func1(); // B 从A 继承了函数Func1
b.Func2(); // B 从A 继承了函数Func2
b.Func3();
b.Func4();
}
这个简单的示例程序说明了一个事实：C++的“继承”特性可以提高程序的可复用性。正因为“继承”太有用、太容易用，才要防止乱用“继承”。我们要给“继承”立一些使用规则：
一、如果类A 和类B 毫不相关，不可以为了使B 的功能更多些而让B 继承A 的功能。
不要觉得“不吃白不吃”，让一个好端端的健壮青年无缘无故地吃人参补身体。
二、如果类B 有必要使用A 的功能，则要分两种情况考虑：
（1）若在逻辑上B 是A 的“一种”（a kind of ），则允许B 继承A 的功能。如男人（Man）是人（Human）的一种，男孩（Boy）是男人的一种。那么类Man 可以从类Human 派生，类Boy 可以从类Man 派生。示例程序如下：
class Human
{
…
};
class Man : public Human
{
…
};
class Boy : public Man
{
…
};
（2）若在逻辑上A 是B 的“一部分”（a part of），则不允许B 继承A 的功能，而是要用A和其它东西组合出B。例如眼（Eye）、鼻（Nose）、口（Mouth）、耳（Ear）是头（Head）的一部分，所以类Head 应该由类Eye、Nose、Mouth、Ear 组合而成，不是派生而成。示例程序如下：
class Eye
{
public:
void Look(void);
};
class Nose
{
public:
void Smell(void);
};
class Mouth
{
public:
void Eat(void);
};
class Ear
{
public:
void Listen(void);
};
// 正确的设计，冗长的程序
class Head
{
public:
void Look(void) { m_eye.Look(); }
void Smell(void) { m_nose.Smell(); }
void Eat(void) { m_mouth.Eat(); }
void Listen(void) { m_ear.Listen(); }
private:
Eye m_eye;
Nose m_nose;
Mouth m_mouth;
Ear m_ear;
};
如果允许Head 从Eye、Nose、Mouth、Ear 派生而成，那么Head 将自动具有Look、Smell、Eat、Listen 这些功能：
// 错误的设计
class Head : public Eye, public Nose, public Mouth, public Ear
{
};
上述程序十分简短并且运行正确，但是这种设计却是错误的。很多程序员经不起“继承”的诱惑而犯下设计错误。
一只公鸡使劲地追打一只刚下了蛋的母鸡，你知道为什么吗？
因为母鸡下了鸭蛋。
本书3.3 节讲过“运行正确”的程序不见得就是高质量的程序，此处就是一个例证。
1.3 虚函数与多态
除了继承外，C++的另一个优良特性是支持多态，即允许将派生类的对象当作基类的对象使用。如果A 是基类，B 和C 是A 的派生类，多态函数Test 的参数是A 的 指针。那么Test 函数可以引用A、B、C 的对象。示例程序如下：
class A
{
public:
void Func1(void);
};
void Test(A *a)
{
a->Func1();
}
class B : public A
{
…
};
class C : public A
{
…
};
// Example
main()
{
A a;
B b;
C c;
Test(&a);
Test(&b);
Test(&c);
};
以上程序看不出“多态”有什么价值，加上虚函数和抽象基类后，“多态”的威力就显示出来了。
C++用关键字virtual 来声明一个函数为虚函数，派生类的虚函数将（override）基类对应的虚函数的功能。示例程序如下：
class A
{
public:
virtual void Func1(void){ cout<< “This is A::Func1 \n”}
};
void Test(A *a)
{
a->Func1();
}
class B : public A
{
public:
virtual void Func1(void){ cout<< “This is B::Func1 \n”}
};
class C : public A
{
public:
virtual void Func1(void){ cout<< “This is C::Func1 \n”}
};
// Example
main()
{
A a;
B b;
C c;
Test(&a); // 输出This is A::Func1
Test(&b); // 输出This is B::Func1
Test(&c); // 输出This is C::Func1
};
如果基类A 定义如下：
class A
{
public:
virtual void Func1(void)=0;
};
那么函数Func1 叫作纯虚函数，含有纯虚函数的类叫作抽象基类。抽象基类只管定义纯虚函数的形式，具体的功能由派生类实现。
结合“抽象基类”和“多态”有如下突出优点：
（1）应用程序不必为每一个派生类编写功能调用，只需要对抽象基类进行处理即可。这一
招叫“以不变应万变”，可以大大提高程序的可复用性（这是接口设计的复用，而不是代码实现的复用）。
（2）派生类的功能可以被基类指针引用，这叫向后兼容，可以提高程序的可扩充性和可维护性。以前写的程序可以被将来写的程序调用不足为奇，但是将来写的程序可以被以前写的程序调用那可了不起。
2.3 new、delete 与指针
在C++中，操作符new 用于申请内存，操作符delete 用于释放内存。在C 语言中，函数malloc 用于申请内存，函数free 用于释放内 存。由于C++兼容C 语言，所以new、delete、malloc、free 都有可能一起使用。new 能比malloc 干更多的事，它可以申请对象的内存，而malloc 不能。C++和C 语言中的指针威猛无比，用错了会带来灾难。对于一个指针p，如果是用new申请的内存，则必须用delete 而不能用free 来释放。如果是用malloc 申请的内存，则必须用free 而不能用delete 来释放。在用delete 或用free 释放p 所指的内存后，应该马上显式地将p 置为NULL，以防下次使用p 时发生错误。示例程序如下：
void Test(void)
{
float *p;
p = new float[100];
if(p==NULL) return;
…// do something
delete p;
p=NULL; // 良好的编程风格
// 可以继续使用p
p = new float[500];
if(p==NULL) return;
…// do something else
delete p;
p=NULL;
}
我们还要预防“野指针”，“野指针”是指向“垃圾”内存的指针，主要成因有两种：
（1）指针没有初始化。
（2）指针指向已经释放的内存，这种情况最让人防不胜防，示例程序如下：
class A
{
public:
void Func(void){…}
};
void Test(void)
{
A *p;
{
A a;
p = &a; // 注意a 的生命期
}
p->Func(); // p 是“野指针”，程序出错
}
2.4 使用const
在定义一个常量时，const 比#define 更加灵活。用const 定义的常量含有数据类型，该常量可以参与逻辑运算。例如：
const int LENGTH = 100; // LENGTH 是int 类型
const float MAX=100; // MAX 是float 类型
#define LENGTH 100 // LENGTH 无类型
#define MAX 100 // MAX 无类型
除了能定义常量外，const 还有两个“保护”功能：
一、强制保护函数的参数值不发生变化
以下程序中，函数f 不会改变输入参数name 的值，但是函数g 和h 都有可能改变name的值。
void f(String s); // pass by value
void g(String &s); // pass by referance
void h(String *s); // pass by pointer
main()
{
String name=“Dog”;
f(name); // name 的值不会改变
g(name); // name 的值可能改变
h(name); // name 的值可能改变
}
对于一个函数而言，如果其‘&’或‘*’类型的参数只作输入用，不作输出用，那么应当在该参数前加上const，以确保函数的代码不会改变该参数的值（如果改变了该参数的值，编译器会出现错误警告）。因此上述程序中的函数g 和h 应该定义成：
void g(const String &s);
void h(const String *s);
二、强制保护类的成员函数不改变任何数据成员的值
以下程序中，类stack 的成员函数Count 仅用于计数，为了确保Count 不改变类中的任何数据成员的值，应将函数Count 定义成const 类型。
class Stack
{
public:
void push(int elem);
void pop(void);
int Count(void) const; // const 类型的函数
private:
int num;
int data[100];
};
int Stack::Count(void) const
{
++ num; // 编译错误，num 值发生变化
pop(); // 编译错误，pop 将改变成员变量的值
return num;
}
ATOM 原子（原子表中的一个字符串的参考）
BOOL 布尔变量
BOOLEAN 布尔变量
BYTE 字节（8位）
CCHAR Windows字符
CHAR Windows字符
COLORREF 红、绿、蓝(RGB)彩色值(32位)
Const 变量，该变量的值在执行期间保持为常量
CRITICAL_SECTION 临界段对象
CTRYID 国名标识符
DLGPROC 指向一个对话框过程的指针
DWORD 双字(32位)
ENHMFENUMPROC 指向一个应用程序定义的回调函数的指针，该回调函数枚举增强的元文件记录
ENUMRESLANGPROC 指向一个应用程序定义的回调函数的指针，该回调函数枚举资源语言。
ENUMRESNAMEPROC 指向一个应用程序定义的回调函数的指针，该回调函数枚举资源名称。
ENUMRESTYPEPROC 指向一个应用程序定义的回调函数的指针，该回调函数枚举资源类型。
FARPROC 指向一个回调函数的指针
FLOAT 浮点变量
FMORDER 32位字体映射值的数组
FONTENUMPROC 指向一个应用程序定义的回调函数的指针，该回调函数枚举字体
GOBJENUMPROC 指向一个应用程序定义的回调函数的指针，该回调函数枚举图形设备接口(GDI)对象
HACCEL 加速键表句柄
HANDLE 对象的句柄
HBITMAP 位图句柄
HBRUSH 画刷句柄
HCONV 动态数据交换(DDE)会话句柄
HCONVLIST DDE会话句柄
HCURSOR 光标句柄
HDC 设备描述表(DC)句柄
HDDEDATA DDE数据句柄
HDLG 对话框句柄
HDWP 延期窗口位置结构句柄
HENHMETAFILE 增强原文件句柄
HFILE 文件句柄
HFONT 字体句柄
HGDIOBJ GDI对象句柄
HGLOBAL 全局内存块句柄
HHOOK 钩子句柄
HICON 图标句柄
HINSTANCE 实例句柄
HKEY 登记关键字句柄
HLOCAL 局部内存块句柄
HMEMU 菜单句柄
HMETAFILE 元文件句柄
HMIDIIN 乐器的数字化接口(MIDI)输入文件句柄
HMIDIOUT MIDI输出文件句柄
HMMIO 文件句柄
HOOKPROC 指向一个应用程序定义的钩子函数的指针
HPALETTE 调色板句柄
HPEN 画笔句柄
HRGN 域句柄
HRSRC 资源句柄
HSZ DDE字符串句柄
HWAVEIN 波形输入文件句柄
HWAVEOUT 波形输出文件句柄
HWINSTA 工作站句柄
HWND 窗口句柄
INT 符号整数
LANGID 语言标识符
LCID 所在国(Locale)标识符
LCTYPE 所在国类型
LINEDDAPROC 指向一个回调函数的指针，该回调函数处理行坐标
LONG 32位符号整数
LP 指向一个以"NULL"结束的Unicode(TM)字符串的指针
LPARAM 32位消息参数
LPBOOL 指向一个布尔变量的指针
LPBYTE 指向一个字节的指针
LPCCH 指向一个Windows字符常量的指针
LPCCHOOKPROC 指向一个应用程序定义的钩子函数的指针
LPCFHOOLPROC 指向一个应用程序定义的钩子函数的指针
LPCH 指向一个Windows字符的指针
LPCOLORREF 指向一个COLORREF值的指针
LPCRITICAL_SECTION 指向一个临界段对象的指针
LPCSTR 指向一个以"NULL"结束的WINDOWS字符串常量的指针
LPCTSTR 指向一个以"NULL"结束的Unicode或Windows字符串常量的指针
LPCWCH 指向一个以"NULL"指向一个以"NULL"结束的Unicode字符常量的指针
LPCWSTR 指向一个以"NULL"指向一个以"NULL"结束的Unicode字符串常量的指针
LPDWORD 指向一个无符号双字(32位)的指针
LPFRHOOLPROC 指向一个应用程序定义的钩子函数的指针
LPHANDLE 指向一个句柄的指针
LOHANDLER_FUNCTION 指向一个处理程序函数的指针
LPHWAVEIN 指向一个波形输入文件句柄的指针
LPHWAVEOUT 指向一个波形输出文件句柄的指针
LPINT 指向一个符号整数的指针
LPLONG 指向一个符号长整数(32位)的指针
LPOFNHOOKPROC 指向一个应用程序定义的钩子函数的指针
LPPRINTHOOKPROC 指向一个应用程序定义的钩子函数的指针
LPSETUPHOOKPROC 指向一个应用程序定义的钩子函数的指针
LPTSTR 指向一个以NULL结束的Unicode或Windows字符串的指针
LRESULT 消息处理的符号结果
LPVOID 指向任何类型的指针
LPWSTR 指向一个以"NULL"结束的Unicode字符串的指针
LUID 局部唯一的标识符
MCIDEVICEID 媒体控制接口(MCI)设备标识符
MFENUMPROC 指向一个应用程序定义的回调函数的指针，该回调函数枚举元文件记录
MMRESULT 多媒体消息的处理结果
NPSTR 指向一个以"NULL"结束的Windows字符串的指针
NWPSTR 指向一个以"NULL"结束的Unicode字符串的指针
PBOOL 指向一个布尔变量的指针
PBYTE 指向一个字节的指针
PCCH 指向一个Windows字符常量的指针
PCH 指向一个Windows字符的指针
PCHAR 指向一个Windows字符的指针
PCRITICAL_SECTION 指向一个临界段对象的指针
PCSTR 指向一个以"NULL"结束的Windows字符串常量的指针
PCWCH 指向一个Unicode字符常量的指针
PCWSTR 指向一个以"NULL"结束的Unicode字符串常量的指针
PDWORD 指向一个无符号双字的指针
PFLOAT 指向一个浮点变量的指针
PFNCALLBACK 指向一个回调函数的指针
PHANDLE 指向一个句柄的指针
PHANDLER_ROUTINE 指向一个处理程序的指针
PHKEY 指向一个登记关键字的指针
PINT 指向一个符号整数的指针
PLONG 指向一个符号长整数的指针
PLUID 指向一个局部唯一的表示符(LUID)的指针
PROPENUMPROC 指向一个应用程序定义的回调函数的指针，该回调函数枚举窗口特征
PSHORT 指向一个符号短整数的指针
PSID 指向一个加密标识符(SID)的指针
PSTR 指向一个以"NULL"结束的Windows字符串的指针
PSZ 指向一个以"NULL"结束的Windows字符串的指针
PTCH 指向一个Windows或Unicode字符的指针
PTCHAR 指向一个Windows或Unicode字符的指针
PTSTR 指向一个以"NULL"结束的Windows或Unicode字符串的指针
PUCHAR 指向一个无符号Windows字符的指针
PUINT 指向一个无符号整数的指针
PULONG 指向一个无符号长整数的指针
PUSHORT 指向一个无符号短整数的指针
PVOID 指向任何类型的指针
PWCH 指向一个Unicode字符的指针
PWCHAR 指向一个Unicode字符的指针
PWORD 指向一个无符号字的指针
PWSTR 指向一个以"NULL"结束的Unicode字符串的指针
REGSAM 登记关键字的加密掩码
SC_HANDLE 服务句柄
SERVICE_STATUS_HANDLE 服务状态值句柄
SHORT 短整数
SPHANDLE 指向一个句柄的指针
TCHAR Unicode或Windows字符
TIMERPROC 指向一个应用程序定义的定时器回调函数的指针
UCHAR 无符号Windows字符
UINT 无符号整数
ULONG 无符号长整数
USHORT 无符号短整数
VOID 任何类型
WCHAR Unicode字符
WNDENUMPROC 指向一个应用程序定义的回调函数的指针，该回调函数枚举窗口
WNDPROC 指向一个应用程序定义的窗口过程的指针
WORD 无符号字(16位)
WPARAM 32位消息参数
YIELDPROC 指向一个输出回调函数的指针
all是一个集合，包含所有html对像的集合，写一个程式，可以存取到所有的对像。像这样：
<script language="javascript">
var obj="";
for(i=0;i<document.all.length;i++)
obj+=document.all[i].tagName+";";
alert(obj);
</script>
注意要把程式放到</html>之后哦。
public class GlobalConfig {
private static final GlobalConfig INSTANCE=new GlobalConfig();
private GlobalConfig (){}//构造方法
}
问题是：当第一次调用这个类时，private static final GlobalConfig INSTANCE=new GlobalConfig(); 被执行 ，然后INSTANCE是不是就一直保留在内存中，不会被java垃圾回收！
If we want the publisher object can be accessed outside the session, there will be two possible
solutions. One is to initialize the publisher explicitly, we can call the method Hibernate.initialize()
for this task. This will force the publisher object to be loaded from database.
Session session = factory.openSession();
try {
Book book = (Book) session.get(Book.class, id);
Hibernate.initialize(book.getPublisher());
return book;
} finally {
session.close();
}
Another solution is to turn off the lazy initialization feature for this association. This may decrease
the performance as the publisher object will be loaded together with the book object every time.
<hibernate-mapping package="mo.org.cpttm.bookshop">
<class name="Book" table="BOOK">
...
<many-to-one name="publisher" class="Publisher" column="PUBLISHER_ID"
lazy="false" />
</class>
</hibernate-mapping>