在C语言中，假设我们有这样的一个函数：
　　
　　int function(int a,int b)
　　
　　调用时只要用result = function(1,2)这样的方式就可以使用这个函数。但是，当高级语言被编译成计算机可以识别的机器码时，有一个问题就凸现出来：在CPU中，计算机没有办法知道一个函数调用需要多少个、什么样的参数，也没有硬件可以保存这些参数。也就是说，计算机不知道怎么给这个函数传递参数，传递参数的工作必须由函数调用者和函数本身来协调。为此，计算机提供了一种被称为栈的数据结构来支持参数传递。

　　栈是一种先进后出的数据结构，栈有一个存储区、一个栈顶指针。栈顶指针指向堆栈中第一个可用的数据项（被称为栈顶）。用户可以在栈顶上方向栈中加入数据，这个操作被称为压栈(Push)，压栈以后，栈顶自动变成新加入数据项的位置，栈顶指针也随之修改。用户也可以从堆栈中取走栈顶，称为弹出栈(pop)，弹出栈后，栈顶下的一个元素变成栈顶，栈顶指针随之修改。

　　函数调用时，调用者依次把参数压栈，然后调用函数，函数被调用以后，在堆栈中取得数据，并进行计算。函数计算结束以后，或者调用者、或者函数本身修改堆栈，使堆栈恢复原装。

　　在参数传递中，有两个很重要的问题必须得到明确说明：
　　
　　当参数个数多于一个时，按照什么顺序把参数压入堆栈
　　函数调用后，由谁来把堆栈恢复原装
　　在高级语言中，通过函数调用约定来说明这两个问题。常见的调用约定有：

　　stdcall
　　cdecl
　　fastcall
　　thiscall
　　naked call

　　stdcall调用约定
　　stdcall很多时候被称为pascal调用约定，因为pascal是早期很常见的一种教学用计算机程序设计语言，其语法严谨，使用的函数调用约定就是stdcall。在Microsoft C++系列的C/C++编译器中，常常用PASCAL宏来声明这个调用约定，类似的宏还有WINAPI和CALLBACK。

　　stdcall调用约定声明的语法为(以前文的那个函数为例）：
　　
　　int __stdcall function(int a,int b)
　　
　　stdcall的调用约定意味着：1）参数从右向左压入堆栈，2）函数自身修改堆栈 3)函数名自动加前导的下划线，后面紧跟一个@符号，其后紧跟着参数的尺寸

　　以上述这个函数为例，参数b首先被压栈，然后是参数a，函数调用function(1,2)调用处翻译成汇编语言将变成：

　　push 2　　　　　　　 第二个参数入栈
　　push 1　　　　　　　 第一个参数入栈
　　call function　　　　调用参数，注意此时自动把cs:eip入栈

　　而对于函数自身，则可以翻译为：
　　push ebp　　　　　　 保存ebp寄存器，该寄存器将用来保存堆栈的栈顶指针，可以在函数退出时恢复
　　mov　ebp, esp　　　　保存堆栈指针
　　mov　eax,[ebp + 8H]　堆栈中ebp指向位置之前依次保存有ebp, cs:eip, a, b, ebp +8指向a
　　add　eax,[ebp + 0CH] 堆栈中ebp + 12处保存了b
　　mov　esp, ebp　　　　恢复esp
　　pop　ebp
　　ret　8

　　而在编译时，这个函数的名字被翻译成_function@8

　　注意不同编译器会插入自己的汇编代码以提供编译的通用性，但是大体代码如此。其中在函数开始处保留esp到ebp中，在函数结束恢复是编译器常用的方法。

　　从函数调用看，2和1依次被push进堆栈，而在函数中又通过相对于ebp(即刚进函数时的堆栈指针）的偏移量存取参数。函数结束后，ret 8表示清理8个字节的堆栈，函数自己恢复了堆栈。

　　
　　cdecl调用约定
　　cdecl调用约定又称为C调用约定，是C语言缺省的调用约定，它的定义语法是：

　　int function (int a ,int b)　//不加修饰就是C调用约定
　　int __cdecl function(int a,int b)//明确指出C调用约定

　　在写本文时，出乎我的意料，发现cdecl调用约定的参数压栈顺序是和stdcall是一样的，参数首先由右向左压入堆栈。所不同的是，函数本身不清理堆栈，调用者负责清理堆栈。由于这种变化，C调用约定允许函数的参数的个数是不固定的，这也是C语言的一大特色。对于前面的function函数，使用 cdecl后的汇编码变成：

　　调用处
　　push 1
　　push 2
　　call function
　　add　esp, 8　　　　　注意：这里调用者在恢复堆栈

　　被调用函数_function处
　　push ebp　　　　　　 保存ebp寄存器，该寄存器将用来保存堆栈的栈顶指针，可以在函数退出时恢复
　　mov　ebp,esp　　　　 保存堆栈指针
　　mov　eax,[ebp + 8H]　堆栈中ebp指向位置之前依次保存有ebp,cs:eip,a,b,ebp +8指向a
　　add　eax,[ebp + 0CH] 堆栈中ebp + 12处保存了b
　　mov　esp,ebp　　　　 恢复esp
　　pop　ebp
　　ret　　　　　　　　　注意，这里没有修改堆栈

　　MSDN中说，该修饰自动在函数名前加前导的下划线，因此函数名在符号表中被记录为_function，但是我在编译时似乎没有看到这种变化。

　　由于参数按照从右向左顺序压栈，因此最开始的参数在最接近栈顶的位置，因此当采用不定个数参数时，第一个参数在栈中的位置肯定能知道，只要不定的参数个数能够根据第一个后者后续的明确的参数确定下来，就可以使用不定参数，例如对于CRT中的sprintf函数，定义为：
　　int sprintf(char* buffer,const char* format,...)
　　由于所有的不定参数都可以通过format确定，因此使用不定个数的参数是没有问题的。

　　fastcall
　　fastcall调用约定和stdcall类似，它意味着：
　　
　　函数的第一个和第二个DWORD参数（或者尺寸更小的）通过ecx和edx传递，其他参数通过从右向左的顺序压栈
　　被调用函数清理堆栈
　　函数名修改规则同stdcall
　　其声明语法为：int fastcall function(int a, int b)

　　thiscall
　　thiscall是唯一一个不能明确指明的函数修饰，因为thiscall不是关键字。它是C++类成员函数缺省的调用约定。由于成员函数调用还有一个this指针，因此必须特殊处理，thiscall意味着：

　　参数从右向左入栈
　　如果参数个数确定，this指针通过ecx传递给被调用者；如果参数个数不确定，this指针在所有参数压栈后被压入堆栈。对参数个数不定的，调用者清理堆栈，否则函数自己清理堆栈为了说明这个调用约定，定义如下类和使用代码：

　　class A
　　{
　　public:
　　　 int function1(int a,int b);
　　　 int function2(int a,...);
　　};

　　int A::function1 (int a,int b)
　　{
　　　 return a+b;
　　}

　　#include <stdarg.h>
　　int A::function2(int a,...)
　　{
　　　 va_list ap;
　　　 va_start(ap,a);
　　　 int i;
　　　 int result = 0;
　　　 for(i = 0 ; i < a ; i ++)
　　　 {
　　　　　result += va_arg(ap,int);
　　　 }
　　　 return result;
　　}

　　void callee()
　　{
　　　 A a;
　　　 a.function1(1, 2);
　　　 a.function2(3, 1, 2, 3);
　　}

callee函数被翻译成汇编后就变成：
　　//函数function1调用
　　00401C1D　 push　　　　2
　　00401C1F　 push　　　　1
　　00401C21　 lea　　　　 ecx,[ebp-8]
　　00401C24　 call　　　　function1　　　　　注意，这里this没有被入栈

　　//函数function2调用
　　00401C29　 push　　　　3
　　00401C2B　 push　　　　2
　　00401C2D　 push　　　　1
　　00401C2F　 push　　　　3
　　00401C31　 lea　　　　 eax, [ebp-8]　　　 这里引入this指针
　　00401C34　 push　　　　eax
　　00401C35　 call　　　　function2
　　00401C3A　 add　　　　 esp, 14h
　　
　　可见，对于参数个数固定情况下，它类似于stdcall，不定时则类似cdecl

　　naked call
　　这是一个很少见的调用约定，一般程序设计者建议不要使用。编译器不会给这种函数增加初始化和清理代码，更特殊的是，你不能用return返回返回值，只能用插入汇编返回结果。这一般用于实模式驱动程序设计，假设定义一个求和的加法程序，可以定义为：

　　__declspec(naked) int　add(int a,int b)
　　{
　　　 __asm mov eax,a
　　　 __asm add eax,b
　　　 __asm ret
　　}

　　注意，这个函数没有显式的return返回值，返回通过修改eax寄存器实现，而且连退出函数的ret指令都必须显式插入。上面代码被翻译成汇编以后变成：

　　mov eax,[ebp+8]
　　add eax,[ebp+12]
　　ret 8

　 注意这个修饰是和__stdcall及cdecl结合使用的，前面是它和cdecl结合使用的代码，对于和stdcall结合的代码，则变成：

　　__declspec(naked) int __stdcall function(int a,int b)
　 {
　　　　__asm mov eax,a
　　　　__asm add eax,b
　　　　__asm ret 8　　　　//注意后面的8
　　}

　　至于这种函数被调用，则和普通的cdecl及stdcall调用函数一致。

　　函数调用约定导致的常见问题
　　如果定义的约定和使用的约定不一致，则将导致堆栈被破坏，导致严重问题，下面是两种常见的问题：

　　函数原型声明和函数体定义不一致
　　DLL导入函数时声明了不同的函数约定
　　以后者为例，假设我们在dll种声明了一种函数为：

　　__declspec(dllexport) int func(int a,int b);//注意，这里没有stdcall，使用的是cdecl
　　使用时代码为：

　　typedef int (*WINAPI DLLFUNC)func(int a,int b);
　　hLib = LoadLibrary(...);

　　DLLFUNC func = (DLLFUNC)GetProcAddress(...)//这里修改了调用约定
　　result = func(1,2);//导致错误

　　由于调用者没有理解WINAPI的含义错误的增加了这个修饰，上述代码必然导致堆栈被破坏，MFC在编译时插入的checkesp函数将告诉你，堆栈被破坏

        POSIX是Portable Operating System Interface of Unix的缩写。由IEEE（Institute of Electrical and Electronic Engineering）开发，由ANSI和ISO标准化。
        POSIX的诞生和Unix的发展是密不可分的，Unix于70年代诞生于Bell lab，并于80年代向美各大高校分发V7版的源码以做研究。UC Berkeley在V7的基础上开发了BSD Unix。后来很多商业厂家意识到Unix的价值也纷纷以Bell Lab的System V或BSD为基础来开发自己的Unix，较著名的有Sun OS，AIX，VMS。由于各厂家对Unix的开发各自为政，造成了Unix的版本相当混乱，给软件的可移植性带来很大困难，对Unix的发展极为不利。为结束这种局面，IEEE开发了POSIX，POSIX在源代码级别上定义了一组最小的Unix(类Unix)操作系统接口。
        POSIX 表示可移植操作系统接口（Portable Operating System Interface ，缩写为 POSIX 是为了读音更像 UNIX）。电气和电子工程师协会（Institute of Electrical and Electronics Engineers，IEEE）最初开发 POSIX 标准，是为了提高 UNIX 环境下应用程序的可移植性。然而，POSIX 并不局限于 UNIX。许多其它的操作系统，例如 DEC OpenVMS 和 Microsoft Windows NT，都支持 POSIX 标准，尤其是 IEEE Std. 1003.1-1990（1995 年修订）或 POSIX.1，POSIX.1 提供了源代码级别的 C 语言应用编程接口（API）给操作系统的服务程序，例如读写文件。POSIX.1 已经被国际标准化组织（International Standards Organization，ISO）所接受，被命名为 ISO/IEC 9945-1:1990 标准。
        POSIX 现在已经发展成为一个非常庞大的标准族，某些部分正处在开发过程中。表 1-1 给出了 POSIX 标准的几个重要组成部分。POSIX 与 IEEE 1003 和 2003 家族的标准是可互换的。除 1003.1 之外，1003 和 2003 家族也包括在表中。

表1：标准的重要组成部分
1003.0
管理 POSIX 开放式系统环境（OSE）。IEEE 在 1995 年通过了这项标准。 ISO 的版本是 ISO/IEC 14252:1996。
1003.1
被广泛接受、用于源代码级别的可移植性标准。1003.1 提供一个操作系统的 C 语言应用编程接口（API）。IEEE 和 ISO 已经在 1990 年通过了这个标准，IEEE 在 1995 年重新修订了该标准。
1003.1b
一个用于实时编程的标准（以前的 P1003.4 或 POSIX.4）。这个标准在 1993 年被 IEEE 通过，被合并进 ISO/IEC 9945-1。
1003.1c
一个用于线程（在一个程序中当前被执行的代码段）的标准。以前是 P1993.4 或 POSIX.4 的一部分，这个标准已经在 1995 年被 IEEE 通过，归入 ISO/IEC 9945-1:1996。
1003.1g
一个关于协议独立接口的标准，该接口可以使一个应用程序通过网络与另一个应用程序通讯。 1996 年，IEEE 通过了这个标准。
1003.2
一个应用于 shell 和 工具软件的标准，它们分别是操作系统所必须提供的命令处理器和工具程序。 1992 年 IEEE 通过了这个标准。ISO 也已经通过了这个标准（ISO/IEC 9945-2:1993）。
1003.2d
改进的 1003.2 标准。
1003.5
一个相当于 1003.1 的 Ada 语言的 API。在 1992 年，IEEE 通过了这个标准。并在 1997 年对其进行了修订。ISO 也通过了该标准。
1003.5b
一个相当于 1003.1b（实时扩展）的 Ada 语言的 API。IEEE 和 ISO 都已经通过了这个标准。ISO 的标准是 ISO/IEC 14519:1999。
1003.5c
一个相当于 1003.1q（协议独立接口）的 Ada 语言的 API。在 1998 年， IEEE 通过了这个标准。ISO 也通过了这个标准。
1003.9
一个相当于 1003.1 的 FORTRAN 语言的 API。在 1992 年，IEEE 通过了这个标准，并于 1997 年对其再次确认。ISO 也已经通过了这个标准。
1003.10
一个应用于超级计算应用环境框架（Application Environment Profile，AEP）的标准。在 1995 年，IEEE 通过了这个标准。
1003.13
一个关于应用环境框架的标准，主要针对使用 POSIX 接口的实时应用程序。在 1998 年，IEEE 通过了这个标准。
1003.22
一个针对 POSIX 的关于安全性框架的指南。
1003.23
一个针对用户组织的指南，主要是为了指导用户开发和使用支持操作需求的开放式系统环境（OSE）框架
2003
针对指定和使用是否符合 POSIX 标准的测试方法，有关其定义、一般需求和指导方针的一个标准。在 1997 年，IEEE 通过了这个标准。
2003.1
这个标准规定了针对 1003.1 的 POSIX 测试方法的提供商要提供的一些条件。在 1992 年，IEEE 通过了这个标准。
2003.2
一个定义了被用来检查与 IEEE 1003.2（shell 和 工具 API）是否符合的测试方法的标准。在 1996 年，IEEE 通过了这个标准。

       除了 1003 和 2003 家族以外，还有几个其它的 IEEE 标准，例如 1224 和 1228，它们也提供开发可移植应用程序的 API。要想得到关于 IEEE 标准的最新信息，可以访问 IEEE 标准的主页，网址是 http://standards.ieee.org/。有关 POSIX 标准的概述信息，请访问 Web 站点 http://standards.ieee.org/reading/ieee/stad_public/description/posix/。

2. Liniux下的线程编程

        Linux系统下的多线程遵循POSIX线程接口，称为pthread。从上面的描述不难知道，POSIX线程接口是POSIX众多标准中的一个（POSIX 1003.1-2001）。

        编写Linux下的多线程程序，需要使用头文件pthread.h，连接时需要使用库libpthread.a。顺便说一下，Linux下pthread 的实现是通过系统调用 clone() 来实现的。clone() 是Linux所特有的系统调用，它的使用方式类似fork，关于 clone() 的详细情况，有兴趣的读者可以去查看有关文档说明。

下面是一个 POSIX 线程的简单示例程序(thread1.c)：

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
 void *thread_function(void *arg) ...{
  int i;
  for ( i=0; i<20; i++) ...{
    printf("Thread says hi! ");
    sleep(1);
  }
  return NULL;
}
int main(void) ...{
  pthread_t mythread;
  
  if ( pthread_create( &mythread, NULL, thread_function, NULL) ) ...{
    printf("error creating thread.");
    abort();
  }
  if ( pthread_join ( mythread, NULL ) ) ...{
    printf("error joining thread.");
    abort();
  }
  exit(0);
}

 要编译这个程序，只需先将程序存为 thread1.c，然后输入：

运行则输入：

3. Windows下POSIX线程编程

       Windows本身没有提供对POSIX的支持。但有一个叫 POSIX Threads for Win32 的开源项目给出了一个功能比较完善的Windows下pthreads API的实现。目前的最新版本是Pthreads-w32 release 2.8.0 (2006-12-22)。

       我没有测试过这个最新版本，这里只给出2.7.0版的链接：ftp://sources.redhat.com/pub/pthreads-win32/pthreads-w32-2-7-0-release.exe。

       关于该开源项目的详细介绍见：http://sources.redhat.com/pthreads-win32/。

3.1 简单使用

       上面的exe文件是一个自解压文件，解压后，Pre-built.2目录中有编译所需要的头文件（include子目录）和库文件（lib子目录）。

       一个简单的测试程序(main.cpp)：

#include <stdio.h>
#include <pthread.h>
#include <assert.h>

void* Function_t(void* Param)
...{
    printf("I am a thread!  ");
    pthread_t myid = pthread_self();
    printf("thread ID=%d ", myid);
    return NULL;
}

int main()
...{
    pthread_t pid;
    pthread_attr_t attr;
    pthread_attr_init(&attr);
    pthread_attr_setscope(&attr, PTHREAD_SCOPE_PROCESS);
    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
    pthread_create(&pid, &attr, Function_t, NULL);
    printf("======================================== ");
    getchar();
    pthread_attr_destroy(&attr);
    return 1;
} 

使用 cl.exe 编译（不熟悉 cl.exe 的请参考：http://blog.csdn.net/liuyongjin1984/archive/2008/01/07/2029405.aspx 或者参见下面3.2部分）：

》rem cl.bat

》cl.exe main.cpp  /c  /I"c:pthreads-w32-2-7-0-releasePre-built.2include"

》link.exe  /out:main_cl.exe  main.obj  /LIBPATH:"c:pthreads-w32-2-7-0-releasePre-built.2lib"   pthreadVC2.lib

 3.2 使用VC++ 6.0或Visual Studio 2005来运行上面的程序

关键有两点：

1. 是将头文件（include子目录）和库文件（lib子目录）中的内容添加到VC++ 6.0或Visual Studio 2005开发环境对应的include和lib目录下。

具体来说（以添加include目录为例，添加lib目录类似）：

图1：VC++ 6.0（添加include目录：工具--》选项--》目录）

图2：Visual Studio 2005(添加include目录：tools--》options)

2. 指定link时要连接的库的名称（pthreadVC2.lib）

图3：VC++ 6.0（工程--》设置--》连接）

图4：Visual Studio 2005(project-->* property pages)

4. 书籍推荐
<< POSIX Multithread Programming Primer >>: http://download.csdn.net/source/237125

int8_t     int16_t     int32_t     int64_t

与其对应的字长固定的无符号型整型类型有：

uint8_t    uint16_t    uint32_t    uint64_t

它们的名字非常直观。例如，int8_t是长度固定为8比特的有符号整型类型，而uint8_t则是字长固定为8比特的无符号型整型类型。当你需要确保在不同的平台上，整型数据的字长固定不变，那么你就可以使用这些typedef名字。

字长最小的快速整型类型
该头文件还定义了另外一套typedef名字，即“最小指定长度的快速整型类型”。这套typedef名字中的每一种都表示一种整数类型，它满足在长度不小于某个指定长度的前提下，拥有最快的处理速度。这些整数类型的名字为int_fastn_t（有符号）或者uint_fastn_t（无符号），其中 “n”表示最小指定长度。例如，int_fast32_t指得是字长至少为32比特的快速有符号整型类型。最小字长快速整型类型有：

int_fast8_t  int_fast16_t  int_fast32_t  int_fast64_t

对应的无符号整型类型有：

uint_fast8_t  uint_fast16_t  uint_fast32_t  uint_fast64_t

什么情况下使用这些typedef名字？
假设你需要一个字长不少于16比特的循环计数器，那么你会希望该计数器的类型总是当前计算机CPU最佳操作的整型类型，而int_fast16_t可以保证任何平台上的编译器总是选择字长不少于16比特的最快整型类型。

#include <inttypes.h>
for (int_fast16_t n=0; n<30000; ++n)
{
//.. do something
}

本文作者Danny Kalev 是一个系统分析家、软件工程师，在C++和面向对象设计方面有着14年的专业经验。

===================================================================

关于整型参数移植

假如你需要确定容量的整型，那么你应该使用stdint.h或者inttypes.h中定义的类型.

这些头文件中定义了以下的整数类型:
int8_t;
uint8_t;
int16_t;
uint16_t;
int32_t;
uint32_t;
int64_t;
uint64_t;

int_least8_t;
uint_least8_t;
int_least16_t;
uint_least16_t;
int_least32_t;
uint_least32_t;
int_least64_t;
uint_least64_t;

int_fast8_t;
uint_fast8_t;
int_fast16_t;
uint_fast16_t;
int_fast32_t;
uint_fast32_t;
int_fast64_t;
uint_fast64_t;

intptr_t;
uintptr_t;

intmax_t;
uintmax_t;

如果是boost库的用户则比较幸运,因为在boost库中,<cstdint.hpp>这个头文件封装了C99标准<stdint.h>中的整数类型.

参考文章：
1.http://blog.vckbase.com/bruceteen/archive/2004/07/27/638.html
2.Danny Kalev的文章:

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=661859

ini文件是技术人员经常用到的一种系统配置方法，如何读取和快速识别ini文件中的内容实现起来比较繁琐。STL强大的功能在于能快速的实现排序、查找、 识别等功能。本文通过STL中的map，string，vector,ifstream等，来快速实现ini文件的识别类class IniFile^?。IniFile可以实现常见查找功能，并提供完整的源码。

1 设计需求：

ini文件的格式一般如下:

[section1]
key1=value1
key2=value2
......

[section2]
key1=value1
key2=value2    #注释
......
实际的例子是：

#ini for path
[path]
dictfile = /home/tmp/dict.dat
inputfile= /home/tmp/input.txt
outputfile= /home/tmp/output.txt

#ini for exe
[exe]
user= winter       //user name
passwd= 1234567    #pass word
database= mydatabase

其中有五种元素：section 名，Key名，value值，注释 #或者//开头,标志字符"[" "]" "="。查找项的对应关系为sectiong-key和value对应。需要得到是value。class IniFile^?要实现的是两个函数：读入ini文件，读取sect-key对应的value值。即实现下面的接口：

class IniFile{
public:
    IniFile();
    //打开ini文件
    bool open(const char* pinipath);
    //读取value值
    const char* read(const char* psect, const char*pkey);
  };

2 设计实现：

用ifstream按行读入ini文件的内容

识别每一行的字符串，分析出sectiong，key，value，和注释。

用map >来记录所有的sectiong－key和value。

重新定义class IniFile^?

typedef map<string, string, less<string> > strMap;
typedef strMap::iterator strMapIt;

const char*const MIDDLESTRING = "_____***_______";
class IniFile
{
public:
    IniFile( ){};
    ~IniFile( ){};
    bool open(const char* pinipath)
    {
        return do_open(pinipath);
    }
    string read(const char*psect, const char*pkey)
    {
        string mapkey = psect;
        mapkey += MIDDLESTRING;
        mapkey += pkey;
        strMapIt it = c_inimap.find(mapkey);
        if(it == c_inimap.end())
            return "";
        else
            return it->second;
    }
protected:
    bool do_open(const char* pinipath)
    {
        ifstream fin(pinipath);
        if(!fin.is_open())
            return false;
        vector<string> strvect;
        while(!fin.eof())
        {
            string inbuf;
            getline(fin, inbuf,'\n');
            strvect.push_back(inbuf);
        }
        if(strvect.empty())
            return false;
        for_each(strvect.begin(), strvect.end(), analyzeini(c_inimap));
        return !c_inimap.empty();
    }
    strMap c_inimap;
};

其中do_open是用来真正实现初始化ini内容的函数。先用ifstream fin打开一个文件，然后用is_open判断文件是否正常打开。顺序读取文件的时候用eof()判断是否到文件尾。getline是一个字符处理函数：直接从fin中读取一行。然后用while循环过滤一行末尾的空格等字符。最后保存到一个vector中，完成读入文本工作。其中比较值得关注的是以下为体，你知道为什么这么做么？

• 用ifstream和getline来读入而不是用fopen和fread。
• 用is_open判断是否打开，而不是直接读取。
• 用vector的push_pack而不是insert。
• 用empty判断是否为空，而不是用size()==0。

下一步用for_each函数来完成字符串的内容提取工作。声明一个结构，实现对操作符()的重载。代码如下：

truct analyzeini{
    string strsect;
    strMap *pmap;
    analyzeini(strMap & strmap):pmap(&strmap){}
    void operator()( const string & strini)
    {
        int first =strini.find('[');
        int last = strini.rfind(']');
        if( first != string::npos && last != string::npos && first != last+1)
        {
            strsect = strini.substr(first+1,last-first-1);
            return ;
        }
        if(strsect.empty())
            return ;
        if((first=strini.find('='))== string::npos)
            return ;
        string strtmp1= strini.substr(0,first);
        string strtmp2=strini.substr(first+1, string::npos);
        first= strtmp1.find_first_not_of(" \t");
        last = strtmp1.find_last_not_of(" \t");
        if(first == string::npos || last == string::npos)
            return ;
        string strkey = strtmp1.substr(first, last-first+1);
        first = strtmp2.find_first_not_of(" \t");
        if(((last = strtmp2.find("\t#", first )) != string::npos) ||
            ((last = strtmp2.find(" #", first )) != string::npos) ||
            ((last = strtmp2.find("\t//", first )) != string::npos)||
            ((last = strtmp2.find(" //", first )) != string::npos))
        {
            strtmp2 = strtmp2.substr(0, last-first);
        }
        last = strtmp2.find_last_not_of(" \t");
        if(first == string::npos || last == string::npos)
            return ;
        string value = strtmp2.substr(first, last-first+1);
        string mapkey = strsect + MIDDLESTRING;
        mapkey += strkey;
        (*pmap)[mapkey]=value;
        return ;
    }
};

函数先找sectiong，然后分离key值和value值。符合要求的，把section和key值通过中间加上MIDDLESTRING组成一个新的string，插入map中。这里值得注意的是：

* for_each的使用，结构可以传递参数。 * string的查找函数及返回值 * string的链接和合并函数。 * map的下标操作符的使用。

3 具体使用

把所有代码放在一个头文件中，以后别人使用的时候，只需要包含头文件就可以了，点击查看inifile.h文件。在使用的过程中，注意判断返回值。使用代码如下：

#include <iostream>
#include "inifile.h"
using namespace std;
int main()
{
    IniFile ini;
    if(!ini.open("test.ini"))
       return -1;
    string strvalue = ini.read("sect1","key1");
    if(strvalue.empty())
        return -1;
    else
        cout<<"value="<<strvalue<<endl;
    return 0;
}  

　　istringstream类用于执行C++风格的串流的输入操作。
　　ostringstream类用于执行C风格的串流的输出操作。
　　strstream类同时可以支持C风格的串流的输入输出操作。

　　istringstream类是从istream（输入流类）和stringstreambase（c++字符串流基类）派生而来，ostringstream是从ostream（输出流类）和stringstreambase（c++字符串流基类）派生而来，stringstream则是从iostream(输入输出流类)和和stringstreambase（c++字符串流基类）派生而来。

　　他们的继承关系如下图所示:

　　istringstream是由一个string对象构造而来，istringstream类从一个string对象读取字符。
　　istringstream的构造函数原形如下：
　　istringstream::istringstream(string str);

//程序作者:管宁 
//站点:www.cndev-lab.com 
//所有稿件均有版权,如要转载,请务必著名出处和作者 
#include <iostream> 
#include <sstream> 
using namespace std; 
int main()  
{ 
istringstream istr; 
istr.str("1 56.7",); 
//上述两个过程可以简单写成 istringstream istr("1 56.7"); 
cout << istr.str()<<endl; 
int a; 
float b; 
istr>>a; 
cout<<a<<endl; 
istr>>b; 
cout<<b<<endl; 
system("pause"); 
}

　　上例中，构造字符串流的时候，空格会成为字符串参数的内部分界，例子中对a,b对象的输入"赋值"操作证明了这一点，字符串的空格成为了整型数据与浮点型数据的分解点，利用分界获取的方法我们事实上完成了字符串到整型对象与浮点型对象的拆分转换过程。

　　str()成员函数的使用可以让istringstream对象返回一个string字符串（例如本例中的输出操作(cout<<istr.str();）。

　　ostringstream同样是由一个string对象构造而来，ostringstream类向一个string插入字符。
　　ostringstream的构造函数原形如下：
　　ostringstream::ostringstream(string str);

　　示例代码如下：

//程序作者:管宁 
//站点:www.cndev-lab.com 
//所有稿件均有版权,如要转载,请务必著名出处和作者 
#include <iostream> 
#include <sstream> 
#include <string> 
using namespace std; 
int main()  
{ 
ostringstream ostr; 
//ostr.str("abc");//如果构造的时候设置了字符串参数,那么增长操作的时候不会从结尾开始增加,而是修改原有数据,超出的部分增长 
ostr.put('d'); 
ostr.put('e'); 
ostr<<"fg"; 
 
string gstr = ostr.str(); 
cout<<gstr; 
system("pause"); 
}

　　在上例代码中，我们通过put()或者左移操作符可以不断向ostr插入单个字符或者是字符串，通过str()函数返回增长过后的完整字符串数据，但值得注意的一点是，当构造的时候对象内已经存在字符串数据的时候，那么增长操作的时候不会从结尾开始增加,而是修改原有数据,超出的部分增长。

　　对于stringstream了来说，不用我多说，大家也已经知道它是用于C++风格的字符串的输入输出的。
　　stringstream的构造函数原形如下：

　　stringstream::stringstream(string str);

　　示例代码如下:

//程序作者:管宁 
//站点:www.cndev-lab.com 
//所有稿件均有版权,如要转载,请务必著名出处和作者 
#include <iostream> 
#include <sstream> 
#include <string> 
using namespace std; 
 
int main()  
{ 
    stringstream ostr("ccc"); 
    ostr.put('d'); 
    ostr.put('e'); 
    ostr<<"fg"; 
    string gstr = ostr.str(); 
    cout<<gstr<<endl; 
 
    char a; 
    ostr>>a; 
    cout<<a 
     
    system("pause"); 
}

　　除此而外，stringstream类的对象我们还常用它进行string与各种内置类型数据之间的转换。

　　示例代码如下：

//程序作者:管宁 
//站点:www.cndev-lab.com 
//所有稿件均有版权,如要转载,请务必著名出处和作者 
#include <iostream> 
#include <sstream> 
#include <string> 
using namespace std; 
 
int main()  
{ 
    stringstream sstr; 
//--------int转string----------- 
    int a=100; 
    string str; 
    sstr<<a; 
    sstr>>str; 
    cout<<str<<endl; 
//--------string转char[]-------- 
    sstr.clear();//如果你想通过使用同一stringstream对象实现多种类型的转换，请注意在每一次转换之后都必须调用clear()成员函数。 
    string name = "colinguan"; 
    char cname[200]; 
    sstr<<name; 
    sstr>>cname; 
    cout<<cname; 
    system("pause"); 
}

　　接下来我们来学习一下输入/输出的状态标志的相关知识，C++中负责的输入/输出的系统包括了关于每一个输入/输出操作的结果的记录信息。这些当前的状态信息被包含在io_state类型的对象中。io_state是一个枚举类型（就像open_mode一样），以下便是它包含的值。

goodbit 无错误

Eofbit 已到达文件尾

failbit 非致命的输入/输出错误，可挽回

badbit　致命的输入/输出错误,无法挽回

　　有两种方法可以获得输入/输出的状态信息。一种方法是通过调用rdstate()函数，它将返回当前状态的错误标记。例如，假如没有任何错误，则rdstate()会返回goodbit.

　　下例示例，表示出了rdstate()的用法：

//程序作者:管宁   
//站点:www.cndev-lab.com   
//所有稿件均有版权,如要转载,请务必著名出处和作者   
 
#include <iostream> 
using namespace std; 
 
int main()  
{ 
    int a; 
    cin>>a; 
    cout<<cin.rdstate()<<endl; 
    if(cin.rdstate() == ios::goodbit) 
    { 
        cout<<"输入数据的类型正确，无错误！"<<endl; 
    } 
    if(cin.rdstate() == ios_base::failbit) 
    { 
        cout<<"输入数据类型错误，非致命错误，可清除输入缓冲区挽回！"<<endl; 
    } 
    system("pause"); 
}

　　另一种方法则是使用下面任何一个函数来检测相应的输入/输出状态：

bool bad();

bool eof();

bool fail();

bool good();

　　下例示例，表示出了上面各成员函数的用法：

//程序作者:管宁 
//站点:www.cndev-lab.com 
//所有稿件均有版权,如要转载,请务必著名出处和作者 
 
#include <iostream> 
using namespace std; 
 
int main()  
{ 
    int a; 
    cin>>a; 
    cout<<cin.rdstate()<<endl; 
    if(cin.good()) 
    { 
        cout<<"输入数据的类型正确，无错误！"<<endl; 
    } 
    if(cin.fail()) 
    { 
        cout<<"输入数据类型错误，非致命错误，可清除输入缓冲区挽回！"<<endl; 
    } 
    system("pause"); 
}

　　如果错误发生，那么流状态既被标记为错误，你必须清除这些错误状态，以使你的程序能正确适当地继续运行。要清除错误状态，需使用clear()函数。此函数带一个参数，它是你将要设为当前状态的标志值。，只要将ios::goodbit作为实参。

　　示例代码如下：

//程序作者:管宁 
//站点:www.cndev-lab.com 
//所有稿件均有版权,如要转载,请务必著名出处和作者 
 
#include <iostream> 
using namespace std; 
 
int main()  
{ 
    int a; 
    cin>>a; 
    cout<<cin.rdstate()<<endl; 
    cin.clear(ios::goodbit); 
    cout<<cin.rdstate()<<endl; 
    system("pause"); 
}

　　通常当我们发现输入有错又需要改正的时候，使用clear()更改标记为正确后，同时也需要使用get()成员函数清除输入缓冲区，以达到重复输入的目的。

　　示例代码如下：

//程序作者:管宁 
//站点:www.cndev-lab.com 
//所有稿件均有版权,如要转载,请务必著名出处和作者 
#include <iostream> 
using namespace std; 
 
int main()  
{ 
    int a; 
    while(1) 
    { 
        cin>>a; 
        if(!cin)//条件可改写为cin.fail() 
        { 
            cout<<"输入有错!请重新输入"<<endl; 
            cin.clear(); 
            cin.get(); 
        } 
        else 
        { 
            cout<<a; 
            break; 
        } 
    } 
    system("pause"); 
}

　　最后再给出一个对文件流错误标记处理的例子，巩固学习，代码如下：

//程序作者:管宁 
//站点:www.cndev-lab.com 
//所有稿件均有版权,如要转载,请务必著名出处和作者 
#include <iostream> 
#include <fstream> 
using namespace std; 
 
int main()  
{ 
    ifstream myfile("c:\\1.txt",ios_base::in,0); 
    if(myfile.fail()) 
    { 
        cout<<"文件读取失败或指定文件不存在!"<<endl; 
    } 
    else 
    { 
        char ch; 
        while(myfile.get(ch)) 
        { 
            cout<<ch; 
        } 
        if(myfile.eof()) 
        { 
            cout<<"文件内容已经全部读完"<<endl; 
        } 
        while(myfile.get(ch)) 
        { 
            cout<<ch; 
        } 
    } 
    system("pause"); 
}

class A
{
public:
    virtual void foo() { cout << "A::foo() is called" << endl;}
};

class B: public A
{
public:
    virtual void foo() { cout << "B::foo() is called" << endl;}
};

那么，在使用的时候，我们可以：

A * a = new B();
a->foo();       // 在这里，a虽然是指向A的指针，但是被调用的函数(foo)却是B的!

    这个例子是虚函数的一个典型应用，通过这个例子，也许你就对虚函数有了一些概念。它虚就虚在所谓“推迟联编”或者“动态联编”上，一个类函数的调用并不是在编译时刻被确定的，而是在运行时刻被确定的。由于编写代码的时候并不能确定被调用的是基类的函数还是哪个派生类的函数，所以被成为“虚”函数。

    虚函数只能借助于指针或者引用来达到多态的效果，如果是下面这样的代码，则虽然是虚函数，但它不是多态的：

class A
{
public:
    virtual void foo();
};

class B: public A
{
    virtual void foo();
};

void bar()
{
    A a;
    a.foo();   // A::foo()被调用
}

1.1 多态
    在了解了虚函数的意思之后，再考虑什么是多态就很容易了。仍然针对上面的类层次，但是使用的方法变的复杂了一些：

void bar(A * a)
{
    a->foo();  // 被调用的是A::foo() 还是B::foo()？
}

因为foo()是个虚函数，所以在bar这个函数中，只根据这段代码，无从确定这里被调用的是A::foo()还是B::foo()，但是可以肯定的说：如果a指向的是A类的实例，则A::foo()被调用，如果a指向的是B类的实例，则B::foo()被调用。

这种同一代码可以产生不同效果的特点，被称为“多态”。

1.2 多态有什么用？
    多态这么神奇，但是能用来做什么呢？这个命题我难以用一两句话概括，一般的C++教程（或者其它面向对象语言的教程）都用一个画图的例子来展示多态的用途，我就不再重复这个例子了，如果你不知道这个例子，随便找本书应该都有介绍。我试图从一个抽象的角度描述一下，回头再结合那个画图的例子，也许你就更容易理解。

    在面向对象的编程中，首先会针对数据进行抽象（确定基类）和继承（确定派生类），构成类层次。这个类层次的使用者在使用它们的时候，如果仍然在需要基类的时候写针对基类的代码，在需要派生类的时候写针对派生类的代码，就等于类层次完全暴露在使用者面前。如果这个类层次有任何的改变（增加了新类），都需要使用者“知道”（针对新类写代码）。这样就增加了类层次与其使用者之间的耦合，有人把这种情况列为程序中的“bad smell”之一。

    多态可以使程序员脱离这种窘境。再回头看看1.1中的例子，bar()作为A-B这个类层次的使用者，它并不知道这个类层次中有多少个类，每个类都叫什么，但是一样可以很好的工作，当有一个C类从A类派生出来后，bar()也不需要“知道”（修改）。这完全归功于多态--编译器针对虚函数产生了可以在运行时刻确定被调用函数的代码。

1.3 如何“动态联编”
    编译器是如何针对虚函数产生可以再运行时刻确定被调用函数的代码呢？也就是说，虚函数实际上是如何被编译器处理的呢？Lippman在深度探索C++对象模型[1]中的不同章节讲到了几种方式，这里把“标准的”方式简单介绍一下。

    我所说的“标准”方式，也就是所谓的“VTABLE”机制。编译器发现一个类中有被声明为virtual的函数，就会为其搞一个虚函数表，也就是VTABLE。VTABLE实际上是一个函数指针的数组，每个虚函数占用这个数组的一个slot。一个类只有一个VTABLE，不管它有多少个实例。派生类有自己的VTABLE，但是派生类的VTABLE与基类的VTABLE有相同的函数排列顺序，同名的虚函数被放在两个数组的相同位置上。在创建类实例的时候，编译器还会在每个实例的内存布局中增加一个vptr字段，该字段指向本类的VTABLE。通过这些手段，编译器在看到一个虚函数调用的时候，就会将这个调用改写，针对1.1中的例子：

void bar(A * a)
{
    a->foo();
}

会被改写为：

void bar(A * a)
{
    (a->vptr[1])();
}

    因为派生类和基类的foo()函数具有相同的VTABLE索引，而他们的vptr又指向不同的VTABLE，因此通过这样的方法可以在运行时刻决定调用哪个foo()函数。

    虽然实际情况远非这么简单，但是基本原理大致如此。

1.4 overload和override
    虚函数总是在派生类中被改写，这种改写被称为“override”。我经常混淆“overload”和“override”这两个单词。但是随着各类C++的书越来越多，后来的程序员也许不会再犯我犯过的错误了。但是我打算澄清一下：

override是指派生类重写基类的虚函数，就象我们前面B类中重写了A类中的foo()函数。重写的函数必须有一致的参数表和返回值（C++标准允许返回值不同的情况，这个我会在“语法”部分简单介绍，但是很少编译器支持这个feature）。这个单词好象一直没有什么合适的中文词汇来对应，有人译为“覆盖”，还贴切一些。
overload约定成俗的被翻译为“重载”。是指编写一个与已有函数同名但是参数表不同的函数。例如一个函数即可以接受整型数作为参数，也可以接受浮点数作为参数。
2. 虚函数的语法
    虚函数的标志是“virtual”关键字。

2.1 使用virtual关键字
    考虑下面的类层次：

class A
{
public:
    virtual void foo();
};

class B: public A
{
public:
    void foo();    // 没有virtual关键字!
};

class C: public B  // 从B继承，不是从A继承！
{
public:
    void foo();    // 也没有virtual关键字！
};

    这种情况下，B::foo()是虚函数，C::foo()也同样是虚函数。因此，可以说，基类声明的虚函数，在派生类中也是虚函数，即使不再使用virtual关键字。

2.2 纯虚函数
    如下声明表示一个函数为纯虚函数：

class A
{
public:
    virtual void foo()=0;   // =0标志一个虚函数为纯虚函数
};

    一个函数声明为纯虚后，纯虚函数的意思是：我是一个抽象类！不要把我实例化！纯虚函数用来规范派生类的行为，实际上就是所谓的“接口”。它告诉使用者，我的派生类都会有这个函数。

2.3 虚析构函数
    析构函数也可以是虚的，甚至是纯虚的。例如：

class A
{
public:
    virtual ~A()=0;   // 纯虚析构函数
};

    当一个类打算被用作其它类的基类时，它的析构函数必须是虚的。考虑下面的例子：

class A
{
public:
    A() { ptra_ = new char[10];}
    ~A() { delete[] ptra_;}        // 非虚析构函数
private:
    char * ptra_;
};

class B: public A
{
public:
    B() { ptrb_ = new char[20];}
    ~B() { delete[] ptrb_;}
private:
    char * ptrb_;
};

void foo()
{
    A * a = new B;
    delete a;
}

    在这个例子中，程序也许不会象你想象的那样运行，在执行delete a的时候，实际上只有A::~A()被调用了，而B类的析构函数并没有被调用！这是否有点儿可怕？

    如果将上面A::~A()改为virtual，就可以保证B::~B()也在delete a的时候被调用了。因此基类的析构函数都必须是virtual的。

    纯虚的析构函数并没有什么作用，是虚的就够了。通常只有在希望将一个类变成抽象类（不能实例化的类），而这个类又没有合适的函数可以被纯虚化的时候，可以使用纯虚的析构函数来达到目的。

2.4 虚构造函数？
    构造函数不能是虚的。

3. 虚函数使用技巧 3.1 private的虚函数
    考虑下面的例子：

class A
{
public:
    void foo() { bar();}
private:
    virtual void bar() { ...}
};

class B: public A
{
private:
    virtual void bar() { ...}
};

    在这个例子中，虽然bar()在A类中是private的，但是仍然可以出现在派生类中，并仍然可以与public或者protected的虚函数一样产生多态的效果。并不会因为它是private的，就发生A::foo()不能访问B::bar()的情况，也不会发生B::bar()对A::bar()的override不起作用的情况。

    这种写法的语意是：A告诉B，你最好override我的bar()函数，但是你不要管它如何使用，也不要自己调用这个函数。

3.2 构造函数和析构函数中的虚函数调用
    一个类的虚函数在它自己的构造函数和析构函数中被调用的时候，它们就变成普通函数了，不“虚”了。也就是说不能在构造函数和析构函数中让自己“多态”。例如：

class A
{
public:
    A() { foo();}        // 在这里，无论如何都是A::foo()被调用！
    ~A() { foo();}       // 同上
    virtual void foo();
};

class B: public A
{
public:
    virtual void foo();
};

void bar()
{
    A * a = new B;
    delete a;
}

    如果你希望delete a的时候，会导致B::foo()被调用，那么你就错了。同样，在new B的时候，A的构造函数被调用，但是在A的构造函数中，被调用的是A::foo()而不是B::foo()。

3.3 多继承中的虚函数 3.4 什么时候使用虚函数
    在你设计一个基类的时候，如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的。从设计的角度讲，出现在基类中的虚函数是接口，出现在派生类中的虚函数是接口的具体实现。通过这样的方法，就可以将对象的行为抽象化。

    以设计模式[2]中Factory Method模式为例，Creator的factoryMethod()就是虚函数，派生类override这个函数后，产生不同的Product类，被产生的Product类被基类的AnOperation()函数使用。基类的AnOperation()函数针对Product类进行操作，当然Product类一定也有多态（虚函数）。

    另外一个例子就是集合操作，假设你有一个以A类为基类的类层次，又用了一个std::vector<A *>来保存这个类层次中不同类的实例指针，那么你一定希望在对这个集合中的类进行操作的时候，不要把每个指针再cast回到它原来的类型（派生类），而是希望对他们进行同样的操作。那么就应该将这个“一样的操作”声明为virtual。

    现实中，远不只我举的这两个例子，但是大的原则都是我前面说到的“如果发现一个函数需要在派生类里有不同的表现，那么它就应该是虚的”。这句话也可以反过来说：“如果你发现基类提供了虚函数，那么你最好override它”。

a. Memory pool management with share memory
b. hash map by custom rules
c. support both fixed nodes and linked list nodes with variable length
d. custom node lookup

coding...