Lua中Metatable这个概念, 国内将他翻译为元表. 元表为重定义Lua中任意一个对象(值)的默认行为提供了一种公开入口. 如同许多OO语言的操作符重载或方法重载. Metatable能够为我们带来非常灵活的编程方式. 

      具体的说, Lua中每种类型的值都有都有他的默认操作方式, 如, 数字可以做加减乘除等操作, 字符串可以做连接操作, 函数可以做调用操作, 表可以做表项的取值赋值操作. 他们都遵循这些操作的默认逻辑执行, 而这些操作可以通过Metatable来改变. 如, 你可以定义2个表如何相加等. 

      看一个最简单的例子, 重定义了2个表的加法操作. 这个例子中将c的__add域改写后将a的Metatable设置为c, 当执行到加法的操作时, Lua首先会检查a是否有Metatable并且Metatable中是否存在__add域, 如果有则调用, 否则将检查b的条件(和a相同), 如果都没有则调用默认加法运算, 而table没有定义默认加法运算, 则会报错.

有了个感性的认识后, 我们看看Metatable的具体特性.

      Metatable并不神秘, 他只是一个普通的table, 在table这个数据结构当中, Lua定义了许多重定义这些操作的入口. 他们均以双下划线开头为table的域, 如上面例子的__add. 当你为一个值设置了Metatable, 并在Metatable中设置了重写了相应的操作域, 在这个值执行这个操作的时候就会触发重写的自定义操作. 当然每个操作都有每个操作的方法格式签名, 如__add会将加号两边的两个操作数做为参数传入并且要求一个返回值. 有人把这样的行为比作事件, 当xx行为触发会激活事件自定义操作.

      在Lua中任何一个值都有Metatable, 不同的值可以有不同的Metatable也可以共享同样的Metatable, 但在Lua本身提供的功能中, 不允许你改变除了table类型值外的任何其他类型值的Metatable, 除非使用C扩展或其他库. setmetatable和getmetatable是唯一一组操作table类型的Metatable的方法.


Metatable与面向对象

      Lua是个面向过程的语言, 但通过Metatable可以模拟出面向对象的样子. 其关键就在于__index这个域. 他提供了表的索引值入口. 这很像重写C#中的索引器, 当表要索引一个值时如table[key], Lua会首先在table本身中查找key的值, 如果没有并且这个table存在一个带有__index属性的Metatable, 则Lua会按照__index所定义的函数逻辑查找. 仔细想想, 这不正为面向对象中的核心思想继承, 提供了实现方式么. Lua中实现面向对象的方式非常多, 但无论哪种都离不开__index.

      这个例子中我使用了Programming In Lua中的实现OO的方式, 建立了Bird(鸟)对象, 拥有会飞的属性, 其他鸟对象基于此原型, Ostrich(鸵鸟)是鸟的一种但不会飞. 结果很明显, Bird和Ostrich分别有独立的状态.

下载源代码：http://www.lua.org/ftp/lua-5.2.1.tar.gz

解压备用。这里说句题外话，lauxlib.h 和 lauxlib.c 我认为也应该是官方的失误，本意应该是 luaxlib.h 和 luaxlib.c 吧？

新建一个 static library 工程，把解压得到的目录下的src子目录中的所有.h和.c文件拷贝到新工程目录下。

工程中删除自动生成的 main.c 文件，添加进除lua.c、luac.c和lua.hpp外的所有.h和.c文件。

编译，得到 libLua.a 即是库。注意，如果你没有重设过输出目录，这个 liblua.a 文件应该在你的源代码目录里。

然后把 libLua.a 放到编译器的 Lib 目录下，把  lauxlib.h、lua.h、luaconf.h、lualib.h 放到编译器的 include 目录下（C++用户再添加个 lua.hpp），最好新建个 lua 子目录存放头文件更清晰。

其实最关键就是除开不必要的文件，实际上：
编译 lua（lua.exe，解析器） 时删除luac.c，加入lua.c。
编译 luac（luac.exe，字节码编译器）时删除lua.c，加入luac.c。
编译 lib和dll（liblua.a和lua.dll，库）时把lua.c和luac.c都删除。

另外要注意：lua 5.2.1 创建一个指向Lua解释器的指针的函数 lua_open 修改为 luaL_newstate。
即把工程从lua5.1库转到5.2库时，在调用 lua_open() 的地方都需要修改为 luaL_newstate()。

在本文中，所有程序均在Linux下开发完成，经测试能够正常运行。 
在开发过程中，我们需要用到gSOAP，可以从以下网址下载获得：[url]http://www.cs.fsu.edu/~engelen/soap.html[/url] 
我下载的是gsoap_2.7.12.tar.gz

下载下来解压缩，按正常安装过程进行编译、安装。

# tar zxvf gsozp_2.7.12.tar.gz 
# cd gsoap_2.7.12 
# ./configure –-prefix=/usr/local/gSOAP（指定安装路径） 
# make 
# make install

1、通过WSDL文档，生成C/C++头文件

# /usr/local/gSOAP/bin/wsdl2h –c –o TestHeader.h [url]http://192.168.0.151:8080/services/TestWS?wsdl[/url]

2、拷贝gSOAP源代码中import文件夹下的stlvector.h文件到TestHeader.h同一目录，如果在解析WSDL文档时使用了-s参数，即不使用STL，则不需要拷贝这一文件。

3、解析TestHeader.h文件，生成存根程序

# /usr/local/gSOAP/bin/soapcpp2 –c –C TestHeader.h

命令中参数-c代表生成标准C程序，若没有这个参数，则生成C++程序。 
命令中参数-C代表仅生成客户端程序，若没有这个参数，则默认生成客户端和服务端程序。

1、新建工程

新建一个C的工程，并将刚刚生成的文件拷贝到工程中，设置工程属性，包含gSOAP源代码目录，链接属性处，需要包含文件libgsoap.a（使用C语言开发）或者libgsoap++.a（使用C++开发）。

2、代码开发

WebService的具体调用方式可以参见生成的soapStub.h文件。

Demo代码（调用WebService的addUser）：

#include “soapH.h” 
#include “TestHeaderHttpBinding.nsmap” 

int main() 
{ 
        struct soap clientSOAP; 
        struct _ns1__addUser addUserMsg; 
        struct _ns1__addUserResponse addUserResponse; 

        soap_init(&clientSOAP); 

        addUserMsg.in0 = “test”; 
        addUserMsg.in1 = “test”; 
        addUserMsg.in2 = “test”; 

        if(soap_call___ns1__addUser(&clientSOAP, NULL, NULL, &addUserMsg, &addUserResponse) == SOAP_OK) 
        { 
                printf(“%s\n”, *addUserResponse.out); 
        } 
        else 
        { 
                printf(“Error\n”); 
        } 
         
        soap_destroy(&clientSOAP); 
        soap_end(&clientSOAP); 
        soap_done(&clientSOAP); 

        return 0; 
}

正常的话，编译运行后能够在控制台看到WebService返回的处理结果。

在这段代码中，_ns1__addUser、_ns1__addUserResponse、soap_call___ns1__addUser都是在soapStub.h中获得，具体应用可能会根据不同的服务端生成不同的代码。

本文出自 “玄武·巴依” 博客，请务必保留此出处http://commandos.blog.51cto.com/154976/130652

一、在你的程序中使用数据库是不错的注意。如果已经有可用的MySQL服务器，在VC中可以按照如下方法实现与数据库的连接。
1、找来MySQL(Win32)安装目录下的include文件夹，将其添加到VC头文件目录列表中；
（VC6 -> Options -> Directories -> 加入此目录）
（VC2005 -> 工具 -> 选择 ->项目和解决方案 -> VC++目录 -> 显示以下內容的目录 -> 包含文件 -> 加入此目录）2、找来MySQL(Win32)安装目录下的lib文件夹，将 其添加到VC库文件目录列表中；
（VC6 -> Options -> Directories -> 加入此目录）
（VC2005 -> 工具 ->选择 -> 项目和解決方案 -> VC++目录 -> 显示以下內容的目录 -> 库文件 -> 加入此目录，注意是lib/debug或lib/opt）
3、新建一个工程，参考如下代码：
// mysql.cpp : Defines the entry point for the console application.

#include "stdafx.h"
#include <stdio.h>
#include <winsock.h>
#include <mysql.h>
#include <windows.h>
#pragma comment(lib, "libmysql.lib")
int main(int argc, char* argv[])
{
    unsigned short Port = 3306;
    char *IPAddress = "192.168.31.56";
    char *UserName = "root";
    char *Password = "";
    char *DBName = "SAS_1_2_0";
    printf("Start... ");
  
    MYSQL *ssock;
    //char execsql[500];
    ssock = (MYSQL *)malloc(sizeof(MYSQL));    
    //在某些版本中，不需要该初始化工作，可观看mysql.H以及readme
    mysql_init(ssock);
    if(ssock == NULL)
    {
        printf("EROR: MySQL ssock init error. ");
        return FALSE;
    }

    //连接到指定的数据库
    ssock = mysql_real_connect(ssock, IPAddress, UserName, Password, NULL, Port, NULL, 0);
    if(!ssock)
    {
        printf("conn fail... ");
        //memcpy(eee, mysql_error(ssock), 20);
        //fprintf(stderr, "Failed to connect to database: Error: %s ", mysql_error(ssock));
        
        //printf("%c ", eee);
        unsigned int mtint = mysql_errno(ssock);
        //printf("%d ");
        return FALSE;
    }
    if(mysql_select_db(ssock, DBName) != 0)
    {
        printf("select db error. ");
        return FALSE;
    }
    printf("version=%d ", mysql_get_server_version(ssock));
    //exec my execsql string
    //sprintf(execsql,"create table girls (name char(10),age int)");
    //mysql_real_query(ssock,execsql,strlen(execsql));
    mysql_close(ssock);
    printf("End... ");
    return TRUE;
} 

二、怎样用c/c++编程连接mysql数据库
     执行一个查询有以下几个步骤要做。首先执行一个查询，然后保存结果，   
     得到的是一个子集。这里是一个小例子：   
  #include   <stdio.h>  
  #include     
  #include   <mysql.h>
  MYSQL   mysql;   
  MYSQL_RES   *res;   
  MYSQL_ROW   row;   
  void   exiterr(int   exitcode)   
  {   
       fprintf(   stderr,   "%s/n",   mysql_error(&mysql)   );   
       exit(   exitcode   );   
  }   
  int   main()   
  {   
        uint   i   =   0;   
        if   (!(mysql_connect(&mysql,"host","username","password")))     
                 exiterr(1);   
        if   (mysql_select_db(&mysql,"payroll"))   
              exiterr(2);   
        if   (mysql_query(&mysql,"SELECT   name,rate   FROM   emp_master"))   
              exiterr(3);   
        if   (!(res   =   mysql_store_result(&mysql)))   
              exiterr(4);   
        while((row   =   mysql_fetch_row(res)))   {   
             for   (i=0   ;   i   <   mysql_num_fields(res);   i++)     
                  printf("%s/n",row[i]);   
        }   
        mysql_free_result(res);   
        mysql_close(&mysql);   
   }   
        mysql_query   函数将把查询送给服务器，如果查询成功，调用mysql_store_result 函数将分配一个MYSQL_RES   结构并且重新从服务器获得一个结果集。
       你可以用mysql_fetch_row   函数来查看数据。这样做你将获得一个   MYSQL_ROW   指针指向数据中的一行。   MYSQL_ROW   指针是一简单的字符串数组。所有的数据类型被转换成字符串送到客户端。   
        mysql_num_fields函数将告诉你返回的列数。你可以继续调用mysql_fetch_row直到它返回一个空指针以得到查询中的每一行。   
        注意在这个例子里，我们没有检查有空指针的列。如果你不使用非空列的表，那么你必须检查一个特殊行的列是否为空。一旦你使用完毕一个结果集，你必须释放它。这通过   mysql_free_result   来完成。   
       最后调用mysql_close来关闭你和数据库之间的连接。   
       查看结果集你可以不用调用mysql_fetch_row就查出返回的结果集共有多少行。这由
      int   mysql_num_rows(MYSQL_RES   *result)来完成。   
       改变到被下一个   mysql_fetch_row   调用返回的行，你可以用void   mysql_data_seek(MYSQL_RES   *res,   uint   offset)   改变到任意一行。  获得更多的信息 你可以使用这几个额外的函数来找出关于一个查询的更多的信息，并从服务器获得这些信息。   
        如果你执行一个UPDATE，   INSERT   或者   DELETE   查询，你可以用int   mysql_affected_rows   来查出共有多少行数据被你影响到。   
       如果在你的数据库里有二进制数据，那么得知数据的长度将是有用的。unsigned  int   *mysql_fetch_lengths(MYSQL_RES   *mysql)   将返回一指出了结果集中每一列 的长度的整型数组。   
      当你插入一个带有   AUTO_INCREMENT   列的表的时候，你可以用int   mysql_insert_id(MYSQL   *mysql)   来查出生成的那一行的ID。   
======================

int main()
{
    MYSQL mysql;
    MYSQL_RES * res ; 
    MYSQL_FIELD * fd ; 
    MYSQL_ROW row ; 
    int id[10000];
    double result[10000][8];
    vector<string> v;

    if(mysql_init(&mysql) == NULL)
    {
     std::cout<<"init mysql data status fail"<<std::endl;
       return false;
   } 
 else
 {
  std::cout<<"init mysql data status success"<<std::endl;
 }
 
 if(NULL == mysql_real_connect(&mysql,"localhost","root","","wsnss",MYSQL_PORT,NULL,0))
 {
  std::cout<<"connect database fail"<<std::endl<<mysql_error(&mysql)<<std::endl;;
  return false;
 }
 else{
  std::cout<<"connect database success"<<std::endl;
 }

 char   szSqlText[500]=""; 
 int j = 0;

 sprintf(szSqlText,"%s","select * from data_receive "); 
 if (mysql_query( &mysql, szSqlText)) 
 //进行数据检索 
 { 
     //执行SQL语句出错 
  cout<<"query error"<<endl;
  mysql_close( &mysql ) ; 
  return FALSE ; 
 } 
    else 
    {
  res = mysql_store_result( &mysql ) ; 
  int i;   
  while((row   =   mysql_fetch_row(res)))   {  
   id[j] = atoi(row[0]);
    for   (i = 1; i < mysql_num_fields(res); i++)   
    {
     result[j][i-1] =  atof(row[i]);
    }
    j++;
  }
    }   
   
  
 for(int i = 0 ; i < 10000; i++)
 {
  if(i>=j)
   break;
  char str[10000];
  stringstream ss;

        ss<<"insert into data_receive(ID,data1,data2,data3, data4,data5,data6,data7,data8)values('"<<id[i]<<"','"<<
   result[i][0]<<"','"<<result[i][1]<<"','"<<result[i][2]<<"','"<<
   result[i][3]<<"','"<<result[i][4]<<"','"<<result[i][5]<<"','"<<
   result[i][6]<<"','"<<result[i][7]<<"');";
  string s = ss.str();
  v.push_back(s);  
 }
 for(vector<string>::iterator iter = v.begin();  iter != v.end(); ++iter)
 {
  
  if(mysql_query(&mysql,(*iter).c_str())!=0)
  {
   std::cout<<"execute insert syntax fail"<<
     std::endl<<mysql_error(&mysql)<<endl;
   mysql_close(&mysql);
   return 1;
  }
 }
    mysql_free_result(res);
    mysql_close(&mysql);
    return 0;
} 

注册C++函数

当Lua 调用C 函数的时候， 使用和C 调用Lua 相同类型的栈来交互。C 函数从栈中获取她的参数， 调用结束后将返回结果放到栈中。为了区分返回结果和栈中的其他的值， 每个C函数还会返回结果的个数 。这儿有一个重要的概念：用来交互的栈不是全局变量， 每一个函数都有他自己的私有栈。当Lua 调用C 函数的时候，第一个参数总是在这个私有栈的index=1 的位置

LUA中可注册的C函数类型

任何在Lua 中注册的函数必须有同样的原型，这个原型声明定义就是lua.h 中的

lua_CFunction ：typedef int (*lua_CFunction) (lua_State *L);

 例子

lua_pushcfunction(l, l_sin);

lua_setglobal(l, "mysin");

第一行将类型为function 的值入栈， 第二行将

function 赋值给全局变量mysin

 
注册任意类型的C函数：

如果要向lua注册一个非lua_CFunction类型的函数，需要：
1． 为该函数实现一个封装调用。
2． 在封装调用函数中从lua栈中取得提供的参数。
3． 使用参数调用该函数。
4． 向lua传递其结果。

 
首先必须有一个LUA规定类型的C函数，例如：

template<typename Func>
int TempCallFun(lua_State* L)

注意这里有个typename Func，是函数的类型，稍后会讲这个的作用

 
然后必须在这个函数中调用真正的C函数，这个函数通过栈来传递，LUA中提供了传递用户数据的接口

用户数据

Lua提供了一个函数可以存储用户数据：

在适当的时刻，我们可以通过这个函数再取出这个数据：

这样我们可以在注册C++函数时，把这个函数指针当作用户数据压栈，然后在调用TempCallFun时把这个函数取出

这里有个关键就是在调用时必须得到正确的参数类型和个数，以正确调用函数并向LUA传递结果，在网上流传的LUA的C++封装中，实现这一功能都是用模板，在TempCallFun中，可以这样调用从栈中取出的函数指针：

buffer = (unsigned char*)lua_touserdata(L,lua_upvalueindex1));//取出用户数据

return Call((*(Func*)buffer),L,1);//调用

注意这个Func就是我们要调用的C++的函数类型，也就是上面说的要把函数指针类型传进来的目的

接下来是Call的其中两个定义

template <typename RT>
int Call(RT (*func)(), lua_State*  L, int index)//匹配没有参数的C++函数
{
     return ReturnType<RT>::Call(func, L, index);
}

template <typename RT, typename P1>
int Call(RT (*func)(P1), lua_State*  L, int index)//匹配有一个参数的C++函数
{
     return ReturnType<RT>::Call(func, L, index);
}

假如有一个 int Test(int a)的C++函数，那么在调用时，就会转到int Call(RT (*func)(P1), lua_State*  L, int index)里面，这样我们就可以在这个函数具体处理有一个参数的C++函数的情况，因为参数类型也已经通过模板传进来了，所以可以继续通过模板来取得把栈中的参数转为正确的类型以供C++函数调用，这里有个技巧是封装栈操作：

template<class T> struct TypeWrapper {};

inline char             Get(TypeWrapper<char>, lua_State*  L, int idx)

inline short            Get(TypeWrapper<short>, lua_State*  L, int idx)

这里的TypeWrapper<typename T>只是为了传递栈中的参数类型

定义所有类型可能的类型的Get函数，就能方便的取得栈中的元素了，在上面的ReturnType<RT>::Call(func, L, index)里面，可以这样调用真正的C++函数，

最后把返回值压栈传给LUA，这样就实现了任意C++函数类型的注册。 注册C++类的成员函数方法一样，只是要把这个类的某个实例也当作用户数据压栈

 
注册C++类

实现这个要比较复杂，因为LUA并不支持面向对象的特性，要实现这个必须通过一些技巧扩展，LUA中的表就是实现这个功能的媒介，也就是用表模拟C++中类的行为，具体实现方法就不详细说了，大家可以去看LuaTinker的代码，这里只说一下要点

表其实就是一种数据元素的集合，每个元素都有一个索引，用户可通过索引来访问表里的元素

 要注册类，关键要做到两点

1、  LUA中的表跟C++中的类的关联，也就是在LUA中构造一个表相应在C++中也必须构造一个类

2、  表中元素跟类中的元素的映射，以得到LUA中的表跟C++中的类的行为的一致性

因为类是自己定义的类型，要实现一个通用的注册类的功能的话，还必须对传递给LUA中的类做一个封装，在LuaTinker中，这个类是：

struct user
{ 
     user(void* p) : m_p(p) {}

  virtual ~user() {}

   void* m_p;

};

template<typename T>
struct val2user : user
{
     val2user() : user(new T) {} //构造函数没有参数的类

   template<typename T1>      //构造函数有一个参数的类
   
      val2user(T1 t1) : user(new T(t1)) {}

   //以此类推。。。。。。。

    ~val2user() { delete ((T*)m_p); }

};

与LUA中的表关联的只是这个val2user，构造一个表就构造一个val2user，在val2user中再构造具体的类

下面是几个在ＬＵＡ中预定义的事件

The __call Metamethod

这是在创建一个表的时候会触发的事件，可以通过在此事件的元方法中调用类的构造函数，以达到在LUA中创建元表的同时在C++中创建类

 
LUA中的表有几个比较重要的预定义的错误行为的事件

The __index Metamethod

当我们访问一个表的不存在的域， 返回结果为nil ， 这是正确的， 但并不一定正确。实际上， 这种访问触发lua 解释器去查找__index metamethod ： 如果不存在， 返回结果为nil ,如果存在则由__index metamethod 返回结果。

The  __newindex metamethod

用来对表更新， __index 则用来对表访问。当你给表的一个缺少的域赋值，解释器就会查找__newindex metamethod ： 如果存在则调用这个函数而不进行赋值操作。像__index 一样， 如果metamethod 是一个表,解释器对指定的那个表， 而不是原始的表进行赋值操作。

可以通过定义这两个特性的元方法来实现对类中变量的访问和设置，因为userdata是没有元素的，所以访问时一定会触发__index，_newindex元方法，通过设置此元方法既可实现对类以及其基类中变量的访问

The  __gc Metamethod

这个元方法只对userdata 类型的值有效。当一个userdatum 将被收集的时候， 并且usedatum 有一个__gc 域， Lua 会调用这个域的值（ 应该是一个函数）：以userdatum作为这个函数的参数调用。这个函数负责释放与userdatum 相关的所有资源。

 
可以设置此事件的元方法来析构类

转自：http://www.cppblog.com/zzxhang/archive/2008/07/16/56311.html

访问微软的MSDN网站后，随即解开了此谜。于是便有了此文 – 如何在VC6 MFC中使用GDI+。

GDI+可应用于二维向量图象，栅格图象及排版，是为C/C++程序员而设计的表现为C++类而存在的接口，能用于一切基于Windows的应用中。作为GDI的后继者，GDI+在GDI中增加了新功能，如文本的反锯齿，渐变笔刷，Alpha溶合；也优化了GDI许多已有的功能。此外，GDI+改变了编程模式，使其更灵活及易用。

GDI+并不限于在.Net中存在，实际上它由Windows XP或Windows Server 2003操作系统提供。它被打包在一个名为GdiPlus.dll的文件中。此文件位于C:\Windows\WinSxS下的相应文件夹下。以笔者的XP系统为例，共有2个版本，其相应的文件夹分别是：

x86_Microsoft.Windows.GdiPlus_6595b64144ccf1df_1.0.0.0_x-ww_8d353f13
x86_Microsoft.Windows.GdiPlus_6595b64144ccf1df_1.0.2600.2180_x-ww_522f9f82

在应用程序中，我们不需指定版本号，系统自动选择最新的版本。先假设我们已经在VC6中编好一个GDI+应用，在degbug版本中单击菜单Build->Start Debug->Go启动调试，再终止应用，在VC6的Output区域中可以看到以下信息：
Loaded 'C:\WINDOWS\WinSxS\x86_Microsoft.Windows.GdiPlus_6595b64144ccf1df_1.0.2600.2180_x-ww_522f9f82\GdiPlus.dll'
说明系统自动选择了最新的版本。

如同Windows是用C语言编写，GdiPlus.dll是以C函数实现的，并没有封装为C++类，从而给非C程序员带来不便。又如同MFC所为，微软再次将这些C函数打包为C++类的形式，向C++程序员提供了以GdiPlus.h领头的30个头文件及一个GdiPlus.lib。因此，如果您是C程序员，则只需GdiPlus.dll就行了；C++程序员则还需要找到GdiPlus.h等头文件及GdiPlus.lib文件。

Windows XP或Windows Server 2003应使用系统自带的GdiPlus.dll，以免与系统服务冲突。而对于版本低于Windows XP的Windows，如Windows NT 4.0 SP6, Windows 2000, Windows98及Windows Me，则需要此文件。可到微软的官方地址去下载分发包gdiplus_dnld.exe文件，地址为：
http://www.microsoft.com/downloads/details.aspx?FamilyID=6a63ab9c-df12-4d41-933c-be590feaa05a&DisplayLang=en

该文件是一个自解压的文件，应将其解压到应用程序的目录下，但不要安装在系统目录中。

C++程序员还应去找GdiPlus.h及GdiPlus.lib。以下地址所提供的名为gdiplus.zip的文件就包括了这些文件：
http://www.crazy-bit.com/download/gdiplus.zip

而以下的地址则提供了一站式的所有资源，即包含了GdiPlus.h等头文件, GdiPlus.lib及GdiPlus.dll：
http://www.codersource.net/samples/mfcgdiplus.zip

根据解压的不同方式，有不同的引用方法。

第一种方法是直接引用，需要将gdiplus.h, gdiplus.lib分别拷贝至VC相应的include及lib目录下。这两个目录可通过VC6的Toos->Options->Directories标签页中，在Show directories for下拉列表框中分别选择Include files及Library files查询到。如Include，一般包括3个路径：VC98\INCLUDE, VC98\MFC\INCLUDE及VC98\ATL\INCLUDE，分别对应非MFC应用，MFC应用及ATL应用所用的不同路径。

然后在StdAfx.h中加入如下的语句：

#define ULONG_PTR ULONG
#include <gdiplus.h>
using namespace Gdiplus;
#pragma comment(lib, "gdiplus.lib")

GdiPlusInit.h中使用了ULONG_PTR的数据类型，但此类型在VC6中没有定义。因此必须在#include语句之前先进行定义。#pragma comment(lib, "gdiplus.lib")指示在连接时在应用所在目录或系统LIB目录下查找gdiplus.lib。

第二种方法是将其解压到任意一个文件夹，然后在StdAfx.h中明确指明具体路径。

#define ULONG_PTR ULONG
#include "C:/gdiplus/Include/gdiplus.h"
using namespace Gdiplus;
#pragma comment(lib, "C:/gdiplus/lib/gdiplus.lib")

除了用以上的方法连接gdiplus.lib之外，还可以在Project->Settings->Link->Object/library modules中输入gdiplus.lib（若有多个库，可用空格隔开，但GDI+只有一个库）。这种方法，可不用在StdAfx.h中输入#pragma comment。

在使用GDI+之前，您必须通过GdiplusStartup()启动GDI+，而在使用完毕后，调用GdiplusShutdown()来清理现场。 根据MFC的特点，应相应地放在XXXApp类的InitInstance()及ExitInstance()中。

先为XXXApp类添加两私有成员变量：
private:
 GdiplusStartupInput gdiplusStartupInput;
 ULONG_PTR gdiplusToken;

然后在InitInstance()中，在调用m_pMainWnd->ShowWindow()及m_pMainWnd->UpdateWindow()之前调用GdiplusStartup()：

 GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);

 // The one and only window has been initialized, so show and update it.
 m_pMainWnd->ShowWindow(SW_SHOW);
 m_pMainWnd->UpdateWindow();
 return TRUE;

注意，如果GdiplusStartup()放在ShowWindow()及UpdateWindow()之后，则当窗口第一次显示时，由于GDI+还未启动，GDI+所画的图形不会显示出来，直到第二个WM_PAINT的消息传到。

而在ExitInstance()中，如下编写代码：

 GdiplusShutdown(gdiplusToken);
 return CWinApp::ExitInstance();

现在，GDI+已经准备完毕，可以使用了。

在XXXView类的OnDraw()方法中：

 Graphics graphics(pDC->m_hDC);
 
 Pen pen(Color(50, 255, 0, 255), 15);
 pen.SetDashStyle(DashStyleDash);
 pen.SetStartCap(LineCapRoundAnchor);
 pen.SetEndCap(LineCapArrowAnchor);
 
 graphics.DrawLine(&pen, 20, 20, 300, 100);
 graphics.DrawLine(&pen, 300, 100, 600, 100);

先使用OnDraw()方法的参数pDC的成员变量m_hDC在堆上构造一个Graphics的实例graphics，创建一个Pen并进行设置，然后通过graphics的DrawLine()方法画出直线来。

与GDI相比较，GDI+不必将Pen, Brush等对象选进DC再画图，而是通过使用DC的句柄来创建一个Graphics实例，之后，直接使用此实例来进行画图。这种风格，确实大大方便了编程人员。

至此，我们可以在VC6 MFC中使用GDI+描绘美好的未来了。:)

转自：http://blog.csdn.net/tanghw/archive/2008/02/17/2100187.aspx

• 标准STL序列容器：vector、string、deque和list。
• 标准STL关联容器：set、multiset、map和multimap。
• 非标准序列容器slist和rope。slist是一个单向链表，rope本质上是一个重型字符串
• 非标准关联容器hash_set、hash_multiset、hash_map和hash_multimap。
• 几种标准非STL容器，包括数组、bitset、valarray、stack、queue和priority_queue

      值得注意的是，数组可以和STL算法配合，因为指针可以当作数组的迭代器使用。

 二.删除元素

 

一个网友提的问题：

Code
void   main() 
{ 
vector <string> vcs; 
vcs.push_back( "this   is   A "); 
vector <string   > ::iterator   it=vcs.begin(); 
int   i=9; 
for(;it!=vcs.end();++it) 
{ 
cout < < "caplity   of   vector   is   :   " < <vcs.size() < <endl; 

cout < < "---> " < <*it < <endl;   //去掉此句会有一个超过vector 
                                   //大小的循环，高手能解释一下为什么? 
if(i==9) 
{ 
vcs.push_back( "this   is   BBBBB "); 
cout < < "vcs.push! " < <endl; 
} 
i=8; 
} 
}
典型的迭代器失效.

 

vector：
1.当插入（push_back）一个元素后，end操作返回的迭代器肯定失效。
2.当插入(push_back)一个元素后，capacity返回值与没有插入元素之前相比有改变，则需要重新加载整个容器，此时first和end操作返回的迭代器都会失效。
3.当进行删除操作（erase，pop_back）后，指向删除点的迭代器全部失效；指向删除点后面的元素的迭代器也将全部失效。

deque迭代器的失效情况：
1.在deque容器首部或者尾部插入元素不会使得任何迭代器失效。
2.在其首部或尾部删除元素则只会使指向被删除元素的迭代器失效。
3.在deque容器的任何其他位置的插入和删除操作将使指向该容器元素的所有迭代器失效。

List/set/map

1.删除时，指向该删除节点的迭代器失效

list<int> intList; 
list<int>::iterator it = intList.begin(); 
while(it != intList.end()) 
{ 
it = intList.erase(it); 
…… 
}

四.选择时机<转>--总结各种容器特点

(1) vector
内部数据结构：数组。
随机访问每个元素，所需要的时间为常量。
在末尾增加或删除元素所需时间与元素数目无关，在中间或开头增加或删除元素所需时间随元素数目呈线性变化。
可动态增加或减少元素，内存管理自动完成，但程序员可以使用reserve()成员函数来管理内存。
vector的迭代器在内存重新分配时将失效（它所指向的元素在该操作的前后不再相同）。当把超过capacity()-size()个元素插入vector中时，内存会重新分配，所有的迭代器都将失效；否则，指向当前元素以后的任何元素的迭代器都将失效。当删除元素时，指向被删除元素以后的任何元素的迭代器都将失效。

(2)deque
内部数据结构：数组。
随机访问每个元素，所需要的时间为常量。
在开头和末尾增加元素所需时间与元素数目无关，在中间增加或删除元素所需时间随元素数目呈线性变化。
可动态增加或减少元素，内存管理自动完成，不提供用于内存管理的成员函数。
增加任何元素都将使deque的迭代器失效。在deque的中间删除元素将使迭代器失效。在deque的头或尾删除元素时，只有指向该元素的迭代器失效。

(3)list
内部数据结构：双向环状链表。
不能随机访问一个元素。
可双向遍历。
在开头、末尾和中间任何地方增加或删除元素所需时间都为常量。
可动态增加或减少元素，内存管理自动完成。
增加任何元素都不会使迭代器失效。删除元素时，除了指向当前被删除元素的迭代器外，其它迭代器都不会失效。

(4)slist
内部数据结构：单向链表。
不可双向遍历，只能从前到后地遍历。
其它的特性同list相似。

(5)stack
适配器，它可以将任意类型的序列容器转换为一个堆栈，一般使用deque作为支持的序列容器。
元素只能后进先出（LIFO）。
不能遍历整个stack。

(6)queue
适配器，它可以将任意类型的序列容器转换为一个队列，一般使用deque作为支持的序列容器。
元素只能先进先出（FIFO）。
不能遍历整个queue。

(7)priority_queue
适配器，它可以将任意类型的序列容器转换为一个优先级队列，一般使用vector作为底层存储方式。
只能访问第一个元素，不能遍历整个priority_queue。
第一个元素始终是优先级最高的一个元素。

(8)set
键和值相等。
键唯一。
元素默认按升序排列。
如果迭代器所指向的元素被删除，则该迭代器失效。其它任何增加、删除元素的操作都不会使迭代器失效。

(9)multiset
键可以不唯一。
其它特点与set相同。

(10)hash_set
与set相比较，它里面的元素不一定是经过排序的，而是按照所用的hash函数分派的，它能提供更快的搜索速度（当然跟hash函数有关）。
其它特点与set相同。

(11)hash_multiset
键可以不唯一。
其它特点与hash_set相同。

(12)map
键唯一。
元素默认按键的升序排列。
如果迭代器所指向的元素被删除，则该迭代器失效。其它任何增加、删除元素的操作都不会使迭代器失效。

(13)multimap
键可以不唯一。
其它特点与map相同。

(14)hash_map
与map相比较，它里面的元素不一定是按键值排序的，而是按照所用的hash函数分派的，它能提供更快的搜索速度（当然也跟hash函数有关）。
其它特点与map相同。

(15)hash_multimap
键可以不唯一。
其它特点与hash_map相同。

头文件
#include <boost/filesystem.hpp>
所有Boost.Filesystem库的内容都处于名空间boost::filesystem之内。

认识basic_path类
在Boost.Filesystem库里basic_path是最重要的类，它以系统无关的方式保存路径、文件名。象std::basic_string 一样，针对char和wchar_t，分别特化了path和wpath。

basic_path的构造函数:

basic_path( const string_type & s ); basic_path( const value_type * s ); template <class InputIterator> basic_path(InputIterator s, InputIterator last);输入参数是一个字符串（或字符迭代器），表示路径名，可以输入系统原生路径名或可移植路径名
原生路径名没啥好说的，比如C:\Windows; D:\abc\ttt.txt等
可移植路径名的定义和Unix的路径定义相同，以“/”作为路径分隔符。

basic_path成员函数:
成员函数 作用 
template <class InputIterator>basic_path& append(InputIterator first, InputIterator last); 将字符串 s 或字符序列 [first,last) 中的路径元素追加到保存的路径中。 
basic_path& remove_filename(); 去除路径中的文件名 
basic_path& replace_extension( const string_type & new_extension = "" ); 替换扩展名 
string_type string() 得到可移植路径名 
string_type file_string() 得到系统原生文件名 
string_type directory_string() 得到系统原生路径名 
string_type root_name() const; 得到根名 
string_type root_directory() const; 得到根目录 
basic_path root_path() const; 得到根路径：根名+根目录 
basic_path relative_path() const; 得到相对路径 
string_type filename() const; 得到文件名 
basic_path parent_path() const; 得到父路径：根路径+相对路径 
string_type stem(const Path & p) const; 得到不带扩展名的文件名 
string_type extension(const Path & p) const; 得到扩展名 
bool empty() const; path未赋值 
bool is_complete() const; 是否是完整路径 
bool has_root_path() const;
bool has_root_name() const;
bool has_root_directory() const;
bool has_relative_path() const;
bool has_filename() const;
bool has_branch_path() const; 路经中是否包含指定的项

测试代码:
#include "boost/filesystem.hpp"   // 包含所有需要的 Boost.Filesystem 声明 
#include <iostream>               // 使用 std::cout 
namespace fs = boost::filesystem; 
// 宏FSTEST：测试f的成员函数，输出成员函数名和结果 
#define FSTEST(x) std::cout << #x##": " << f.x << std::endl 
int main() 
{ 
fs::path f("\\folder1\\folder2\\folder3\\filename.ext"); 

FSTEST(string()); 
FSTEST(file_string()); 
FSTEST(directory_string()); 
FSTEST(root_name()); 
FSTEST(root_directory()); 
FSTEST(root_path()); 
FSTEST(relative_path()); 
FSTEST(filename()); 
FSTEST(parent_path()); 
FSTEST(stem()); 
FSTEST(extension()); 

FSTEST(replace_extension("new")); 
char buf[]="hello"; 
FSTEST(append(buf, buf+sizeof(buf))); 
FSTEST(remove_filename()); 

return 0; 
}

输出：
string(): /folder1/folder2/folder3/filename.ext file_string(): \folder1\folder2\folder3\filename.ext directory_string(): \folder1\folder2\folder3\filename.ext root_name(): root_directory(): / root_path(): / relative_path(): folder1/folder2/folder3/filename.ext filename(): filename.ext parent_path(): /folder1/folder2/folder3 stem(): filename extension(): .ext replace_extension("new"): /folder1/folder2/folder3/filename.new append(buf, buf+sizeof(buf)): /folder1/folder2/folder3/filename.new/hello remove_filename(): /folder1/folder2/folder3/filename.new/

常用函数
函数名 作用 
system_complete(path); 返回完整路径(相对路径+当前路径) 
exists(path); 文件是否存在 
is_directory(path);
is_directory(file_status); 是否是路径 
is_regular_file(path);
is_regular_file(file_status); 是否是普通文件 
is_symlink(path);
is_symlink(file_status); 是否是一个链接文件 
file_status status(path); 返回路径名对应的状态 
template <class Path> const Path& initial_path(); 得到程序运行时的系统当前路径 
template <class Path> Path current_path(); 得到系统当前路径 
template <class Path> void current_path(const Path& p); 改变当前路径 
template <class Path> space_info space(const Path& p); 得到指定路径下的空间信息，space_info 有capacity, free 和 available三个成员变量，分别表示容量，剩余空间和可用空间。 
template <class Path> std::time_t last_write_time(const Path& p); 最后修改时间 
template <class Path> void last_write_time(const Path& p, const std::time_t new_time); 修改最后修改时间 
template <class Path> bool create_directory(const Path& dp); 建立路径 
template <class Path1, class Path2> void create_hard_link(const Path1& to_p, const Path2& from_p);
template <class Path1, class Path2> error_code create_hard_link(const Path1& to_p, 
const Path2& from_p, error_code& ec); 建立硬链接 
template <class Path1, class Path2> void create_symlink(const Path1& to_p, const Path2& from_p);
template <class Path1, class Path2> error_code create_symlink(const Path1& to_p, const Path2& from_p, error_code& ec); 建立软链接 
template <class Path> void remove(const Path& p, system::error_code & ec = singular ); 删除文件 
template <class Path> unsigned long remove_all(const Path& p); 递归删除p中所有内容，返回删除文件的数量 
template <class Path1, class Path2> void rename(const Path1& from_p, const Path2& to_p); 重命名 
template <class Path1, class Path2> void copy_file(const Path1& from_fp, const Path2& to_fp); 拷贝文件 
template <class Path> Path complete(const Path& p, const Path& base=initial_path<Path>()); 以base以基，p作为相对路径，返回其完整路径 
template <class Path> bool create_directories(const Path & p); 建立路径

路径迭代器
basic_directory_iterator
构造函数：

explicit basic_directory_iterator(const Path& dp); basic_directory_iterator();basic_directory_iterator 从构造参数得到目录，每一次调用 operator++，它就查找并得到下一个文件名直到目录元素的末尾。不带参数的构造函数 basic_directory_iterator() 总是构造一个 end 迭代器对象，它是唯一一个用于结束条件的合法迭代器。

示例代码，得到指定目录下的所有文件名：
void find_file( const fs::path & dir_path ) 
{ 
if ( !fs::exists( dir_path ) ) return; 
fs::directory_iterator end_itr; // 缺省构造生成一个结束迭代器 
for ( fs::directory_iterator itr( dir_path ); 
itr != end_itr; 
++itr ) 
{ 
if ( fs::is_directory(itr->status()) ) 
{ 
find_file( itr->path() ); //递归查找 
} 
else 
{ 
std::cout << *itr << std::endl; 
} 
} 
}

basic_recursive_directory_iterator
递归遍历目录的迭代器，它的构造参数与basic_directory_iterator相同，当调用 operator++时，如果当前值是一个目录，则进入下一级目录。
它有三个成员函数： 函数名 作用 
int level() const; 得到当前搜索深度 
void pop(); 调用pop()后，下一次递增就会直接返回上一级目录 
void no_push(); 调用no_push()后，即便下一个元素是目录类型也不进入

示例代码，得到指定目录下的所有文件名（和上例作用相同）：
void find_file2( const fs::path & dir_path ) 
{ 
fs::recursive_directory_iterator end_itr; // 缺省构造生成一个结束迭代器 
for ( fs::recursive_directory_iterator itr( dir_path ); 
itr != end_itr; 
++itr ) 
{ 
std::cout << itr.level() << *itr << std::endl; 
}

转自：http://hi.baidu.com/dulamhoo/blog/item/c501e83a48c2bcf4838b1380.html

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import ConfigParser

config = ConfigParser.ConfigParser()
config.readfp(open('update.ini'))

a = config.get("ZIP","MD5")
print a

写也很简单：

import ConfigParser

config = ConfigParser.ConfigParser()

# set a number of parameters
config.add_section("book")
config.set("book", "title", "the python standard library")
config.set("book", "author", "fredrik lundh")

config.add_section("ematter")
config.set("ematter", "pages", 250)

# write to file
config.write(open('1.ini', "w"))

×××××××××××××××××××××××××××××××××××××××××
修改也不难（添加内容）：

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import ConfigParser

config = ConfigParser.ConfigParser()

config.read('1.ini')

a = config.add_section("md5")

config.set("md5", "value", "1234")

config.write(open('1.ini', "r+"))     #可以把r+改成其他方式，看看结果:)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import ConfigParser

config = ConfigParser.ConfigParser()

config.read('1.ini')

config.set("md5", "value", "kingsoft")    #这样md5就从1234变成kingsoft了

config.write(open('1.ini', "r+"))

remove_option(

section, option)

Remove the specified option from the specified section. If the section does not exist, raise NoSectionError. If the option existed to be removed, return True; otherwise return False.New in version 1.6.

remove_section(

section)

Remove the specified section from the configuration. If the section in fact existed, return True. Otherwise return False.

转自：http://hi.baidu.com/saya_sj/blog/item/b68ea92ea82ced594fc22619.html

以从所未有如此容易的方法将常数或生成的数据填入容器。
简介

本库的目的是通过重载operator,() 和 operator()()使 得将数据填入容器中可以更容易。这两个操作符让我们可以构造一列数据然后把它们拷贝进容器中：
用逗号分隔的列表：
vector<int> v; 
v += 1,2,3,4,5,6,7,8,9;
用括号分隔的列表：
map<string,int> m; 
insert( m )( "Bar", 1 )( "Foo", 2 );
除了insert外，push_back，push_front也能用于相应数据结构的对象中（比如deque）。

list_of函数
用于初始化一个容器
list<int> primes = list_of(1)(2)(3)(5)(7)(11);
map_list_of函数
也是初始化容器，为方便map而特别定义的。以前map的添加多用make_pair。
map<int,int> next = map_list_of(1,2)(2,3)(3,4);

truple_list_of函数
同map一样，为truple定制的。
vector<tuple> v = tuple_list_of( 1, "foo", 2 )( 3, "bar", 4 );

函数 repeat(), repeat_fun() 和 range()
多次重复相同的值有时是很烦人的。这时使用 repeat() 会很方便：
vector<int> v;
v += 1,2,3,repeat(10,4),5,6,7,8,9;
// v = [1,2,3,4,4,4,4,4,4,4,4,4,4,5,6,7,8,9]
v = list_of(1).repeat(5,2)(3);
// v = [1,2,2,2,2,2,3]
push_back( v )(1).repeat(1,2)(3);
// v = old v + [1,2,3]
正如我们所见，repeat()的第一个参数是重复第二个参数的次数。

template< class T >
struct next {
T seed;
next( T seed ) : seed(seed) { }

T operator()() {
return seed++;
}
};

vector<int> v;
v += 1,2,repeat_fun(4,&rand),4;
// v = [1,2,?,?,?,?,4] 
push_back( v ).repeat_fun(4,next<int>(0))(4).repeat_fun(4,next<int>(5));
// v = old v + [0,1,2,3,4,5,6,7,8] 

对 repeat_fun() 的第二个参数的唯一要求是，它必须是一个无参函数。
vector<int> v, v2;
v = list_of(1)(2)(3);
v2 = list_of(0).range(v).range(v.begin(),v.end())(4);
// v2 = [0,1,2,3,1,2,3,4]
区域插入也实现了。

ref_list_of和cref_list_of函数
有时需要一个匿名容器，比如用作参数等。ref_list_of也是建立一个容器，只是容器中的值是引用。

头文件
这个库的头文件非常多，原因是它对STL作了扩充，又因为STL各个库的使用也要调用不同的头文件，这里也保持这个约定。
Header头文件 Includes包含
<boost/assign.hpp> 除了对指针容器的支持以外的所有东西
<boost/assign/list_of.hpp> list_of(), map_list_of(), tuple_list_of(), ref_list_of() 和 cref_list_of()
<boost/assign/std.hpp> 各个标准容器的 operator+=() (见后)
<boost/assign/std/deque.hpp> std::deque的operator+=(), <deque>
<boost/assign/std/list.hpp> std::list的operator+=(), <list>
<boost/assign/std/map.hpp> std::map 和 std::multimap 的 operator+=(), <map>
<boost/assign/std/queue.hpp> std::queue 和 std::priority_queue 的 operator+=(), <queue>
<boost/assign/std/set.hpp> std::set 和 std::multiset 的 operator+=(), <set>
<boost/assign/std/slist.hpp> std::slist 的 operator+=(), <slist> (如果有slist)
<boost/assign/std/stack.hpp> std::stack 的 operator+=(), <stack>
<boost/assign/std/vector.hpp> std::vector 的 operator+=(), <vector>
<boost/assign/assignment_exception.hpp> 类 assignment_exception， 可能会由 list_of() 返回的代理所抛出
<boost/assign/list_inserter.hpp> make_list_inserter(), push_back(), push_front(),insert(), push() 和类 list_inserter， 是整个库的骨干
<boost/assign/ptr_list_inserter.hpp> 函数 ptr_push_back(), ptr_push_front() 和 ptr_insert()
<boost/assign/ptr_map_inserter.hpp> 函数 ptr_map_insert()
<boost/assign/ptr_list_of.hpp> 函数 ptr_list_of()

小结
如题，从未有过如此简单的赋值方式。

转自：http://hi.baidu.com/ani_di/blog/item/30eaca1ebc38b069f624e48d.html

我曾在很多C＋＋书籍中看到作者们抱怨标准库中没有实现hash_set或hase_map，并非常自信地声称在下一个标准库中一定会增加这两个。我搜索的帮助文档后，很遗憾地没有发现相关库。难道C＋＋的狂热爱好者把这么重要的库给忘记了吗？Boost.Functional/hash库引进了我的注意，遵循它的指引，我一步一步发发现的散列表的踪迹。

hash        <boost/functional/hash.hpp>

观察头文件的写法，就知道hash是functional库中的一员，更进一步，如果你用过STL中的<functional>，那么多半你也猜到，hash是一个函数。不太完全正确，实事上它是一个函数对象。boost中实现的散列表，使用的散列函数就是它（至于boost中有那些散列函数，以后再列举）。

如果直接使用hash，先创建一个实例并像函数一样调用它：

       hash<string> string_hash;

       size_t h = string_hash(“Love”);

它支持的类型有

integers

floats

pointers

strings

扩展类型有

arrays

std::pair

标准容器

定制的类型扩展

如何定制类型

要编写一个hash可用的类型，两个必须实现的功能是operator== 和 hash_value，参考下面的实现：

namespace library {

       struct book {

              int id;

              std::string titile;

       };

       std::size_t hash_value(const book& b) {

              boost::hash<int> hasher;

              return hasher(b.id); // 可以自己写哈希函数

       }

       bool operator== (const book& a, const book& b) const {

              return a.id == b.id;

       }

}; // namespace library

结合散列值

纵观上面的hash使用方法，只能对一个参数可hash值。库也提供了多个参数，示例：

class point {

       int x, y;

public:

       … …

       bool operator==(const point& other) const {      

              return x == other.x && y == other.y;

       }

       friend std::size_t hash_value(const point& p) {

              std::size_t seed = 0;

              boost::hash_combin(seed, p.x);     // combin 的顺序不同，得出的结果也不同

              boost::hash_combin(seed, p.y);

              return seed;

};

Unordered      <boost/unordered_set.hpp> ,<boost/unordered_map.hpp>

这个库实现了无序关联容器。从某种意义上说，它就是我们需要的散列表。

与有序关联容器不同的是，它不需要比较，而是需要hash值。我下面列出它的声明，以求不要理解错了。

namespace boost {

       template <

              class Key,

              class Hash = boost::hash<Key>,

              class Pred = std::equal_to<Key>,

              class Alloc = std::alloctor<Key> >

       class unordered_set;

}

如果class不是标准库里的类型，那么hash和equal_to的非常关键了。

使用

unordered_set、unordered_map与set、map在使用上基本一致。请参考它们的写法。

更深层次的探索

散列表一个不可避免的问题即是“冲突”，解决冲突的方法有很多，有分离链表法、线性探测等。据我所知道，分离链表法是在各种库最常用的方法。unordered的实现用到了桶（bucket），这属于分离链表的变体。每桶对应的是索引，桶里可以有很多元素，它们都是“冲突”的。

线性探测中，一个非常重要的数据就是：装填因子λ，它是散列表中的元素个数与散列表大小的比值。对于探测散列表，λ≈0.5；对于分离链表，λ≈1。在手册中，unordered中负载因子（load factor）的解释是“the average number of elements per bucket”，平均每个桶中元素的个数，在数学上，此处的负载因子与前面的装填因子λ等价。

以下几个函数用于控制桶的大小

X( size_type n)                                  构造一个新容器，带有n个桶

X( InputIterator i, InputIterator j, size_type n)            构造有n个的容器，插入区间[i, j)。

float load_factor( ) const                            每个桶中的平均数量

float max_load_factor( ) const             当前最大的负载因子

float max_load_factor( float z)             修改最大负载因子，z做为参数

void rehash( size_type n)                     修改桶使至少为n个，且负载因子小于最大负载因子

除了 rehash 以外，其它成员函数如何影响桶的数量并没有规定，insert 操作仅当插入导致负载因子大于或等于最大负载因子时允许使得迭代器失效。对于多数实现来说，这意味着只有当此事发生时，插入操作才会改变桶的数量。因此，迭代器只会在调用 insert 和 rehash 时才可能失效，而指向容器中的元素的指针和引用则永不失效。

转自：http://hi.baidu.com/ani_di/blog/item/41406ce6df3c1f24b83820c1.html

    Pool分配是一种分配内存方法，用于快速分配同样大小的内存块，
    尤其是反复分配/释放同样大小的内存块的情况。

1. pool

2. object_pool   

3. singleton_pool

4. pool_alloc

    基于singleton_pool实现，提供allocator（用于STL等）。

    Example:

    需要的话，必须自己显式地调用
    boost::singleton_pool<boost::pool_allocator_tag, sizeof(int)>::release_memory()
    把allocator分配的内存返回系统。

实现原理

    pool每次向系统申请一大块内存，然后分成同样大小的多个小块，
    形成链表连接起来。每次分配的时候，从链表中取出头上一块，提
    供给用户。链表为空的时候，pool继续向系统申请大块内存。
    一个小问题：在pool的实现中，在申请到大块内存后，马上把它分
    成小块形成链表。这个过程开销比较大。即你需要分配一小块内存
    时，却需要生成一个大的链表。用如下代码测试:

    可以发现，第一遍花的时间明显多于后面的。

    而且在pool的使用过程中如果不是恰好把链表中所有的小块都用上
    的话，在链表中最后的一些小块会始终用不上。把这些小块加入链
    表是多余的。虽然这个开销可能很小:)
 

转自：http://blog.csdn.net/xushiweizh/archive/2006/11/21/1400426.aspx

     目前能实现C++集成Lua的有很多。比较常见的有LuaPlus,LuaBind,ToLua++,LuaWrapper等。这几种我都试过了，各有优缺点。

    LuaBind，确实不错，很强大。如果不是它需要Boost库支持的话我就选它了。

    ToLua++，我只是粗略的看了下，因为编译太麻烦，很快就放弃了。不过看网上评价还不错。

    LuaWrapper，国内前辈所出，本想支持一下，可一看说明还是需要Boost，只好放弃了。

并不是因为Boost不好，而是因为我的项目连带工程源代码都要投递去应聘的，不能保证对方机器上也安装了Boost库。

    最后还是选择了LuaPlus，感觉还可以，下面是使用经验总结。

1。创建一个State。

   LuaStateOwner* pState = NULL;
   pState = new LuaStateOwner(true);
   if ( !pState )
    return E_OUTOFMEMORY;

注意：LuaStateOwner构造函数参数true表示在构造的过程中对Lua标准库进行初始化。这一点非常重要。一开始我调用的不带参数的构造函数，然后在.lua中调用math.random()的时侯就一直失败，今天研究了一下午才弄明白的。

2. 注册C＋＋函数到Lua
   (这一点我没试，直接引用示例里的)

static int PrintLSNumber(LuaState* state)
{
     LuaStack args(state);

    // Verify it is a number and print it.
    if (args[1].IsNumber()) {
         printf("%f ", args[1].GetNumber());
     }
    // No return values.
    return 0;
}

   LuaObject globalsObj = (*pState)->GetGlobals();
   globalsObj.Register("PrintNumber", PrintLSNumber);

3。注册C＋＋类成员函数到Lua

   LuaObject globalsObj = (*pState)->GetGlobals();
   CTest test; //CTest为类名
   globalsObj.RegisterDirect( "update", test, &CTest::Update );

Update为CTest的一个成员函数，

双引号中的update是指注册到Lua中的函数名,在lua脚本中使用update()即调用了test对象的Update()函数。

4.从文件中载入并执行脚本

   int iret = (*pState)->DoFile( "test.lua" );
   if ( 0 != iret )
    return false;
返回值为0表示成功,否则不成功.

5.C＋＋获取Lua脚本中的变量

   float x = (*pState)->GetGlobal( "x" ).GetFloat();
   注意,要在DoFile之后才能从lua中获取变量，此时文件已被载入。

6.C＋＋中调用脚本里的函数

      LuaFunction<bool> RandBuild = (*pState)->GetGlobal("RandBuild");
     bool ret = RandBuild();

     test.lua文件中：

     function RandBuild()
           math.random(); --第一次的随机数太小，合弃
          x = math.random( -100, 100 );
         return true;
     end;

7.Lua脚本中调用C++函数

    这里可以调用的就是前面注册过的C＋＋函数，调用时直接使用注册时的函数名。
    比如第3步中的，如果脚本中写update()，就相当于在C＋＋中test.Update();

8.C＋＋中直接调用注册的Lua函数

    (*pState)->DoString( "update()" );
    这一句意思是只执行"update()"这一句脚本。

另外，项目目录下还要放上LuaPlus和Lua的头文件，还有LuaPlus的.lib和.dll。这些可以在LuaPlus网站上下载到。http://luaplus.org/tiki-index.php?page=LuaPlus+Home+Page
草草的写完，有点乱，就将就着看吧。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/yjn001/archive/2009/01/16/3795842.aspx

执行上述代码后，可以想到产生的结果就像这样： 
 
这张图很好，显示了reverse_iterator和它对应的base iterator之间特有的偏移量，就像rbegin()和rend()与相关的begin()和end()一样，但并没有说出了所有你需要知道的东西。特别是，它并没有解释怎样在ri上实现你在i上想要完成的操作。有些容器的成员函数只接受iterator类型的参数，所以如果你想要在ri所指的位置插入一个新元素，你不能直接这么做，因为vector的insert函数不接受reverse_iterator。如果你想要删除ri 所指位置上的元素也会有同样的问题。erase成员函数会拒绝reverse_iterator，坚持要求iterator。为了完成删除和一些形式的插入操作，你必须先通过base函数将reverse_iterator转换成iterator，然后用iterator来完成工作。
先让我们假设你要在ri指出的位置上把一个新元素插入v。特别的，我们假设你要插入的值是99。记住ri在上
图中遍历的顺序是自右向左，而且插入操作会将新元素插入到ri位置，并且将原先ri位置的元素移到遍历过程
的“下一个”位置，我们认为3应该出现在99的左侧。插入操作之后，v看起来像这样： 
 
当然，我们不能用ri来指定插入的地方，因为它不是一个iterator。我们必须用i来代替。如上所述，当ri指向3时，i（就是ri.base()）指向4。如果我们用ri来指定插入位置，那么用i指向插入位置，那个假设就是正确的。结论呢？
● 要实现在一个reverse_iterator ri指出的位置上插入新元素，在ri.base()指向的位置插入就行了。对于
insert操作而言，ri和ri.base()是等价的，而且ri.base()真的是ri对应的iterator。
现在再来考虑删除元素的情况。回顾一下最初的vector（也就是在插入99之前）ri与i的关系： 
 
如果你要删除ri指向的元素，你不能直接使用i了，因为i与ri不是指向同一个元素。因此，你要删除的是i的前一个元素。
● 要实现在一个reverse_iterator ri指出的位置上删除元素，就应该删除ri.base()的前一个元素。对于删除操作而言，ri和ri.base()并不等价，而且ri.base()不是ri对应的iterator。
我们还是有必要看看删除操作的代码，因为它还挺令人惊讶的。

这个设计并不存在什么问题。表达式--ri.base()确实能够指出我们需要删除的元素。而且，它们能够处理除了
vector和string之外的其他所有容器。它可能也能处理vector和string，但对于大多数vector和string的实现，它无。在这样的实现下，iterator（和const_iterator）会采用内建的指针来实现，所以ri.base()的结果是一个指针。C和C++都规定了不能直接修改函数返回的指针，所以在string和vector的迭代器是指针的STL平台上，像--ri.base()这样的表达式无法通过编译。要移植从一个由reverse_iterator指出的位置删除元素时，你应该尽量避免修改base的返回值。没问题。如果你不能减少调用base的返回值，只需要先增加reverse_iterator的值，然后再调用base！

 // 同上 
v.erase((++ri).base()); // 删除ri指向的元素； 
// 这下编译没问题了！

因为这个方法适用于所有的标准容器，这是删除一个由reverse_iterator指出的元素时首选的技巧。
现在已经很清楚了，reverse_iterator的base成员函数返回一个“对应的”iterator的说法并不准确。对于插入操作而言，的确如此；但是对于删除操作，并非如此。当需要把reverse_iterator转换成iterator的时候，有一点非常重要的是你必须知道你准备怎么处理返回的iterator，因为只有这样你才能决定你得到的iterator是否是你需要的。

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/kuanghong/archive/2008/08/20/2801280.aspx

原主题：http://www.gamedev.net/community/forums/topic.asp?topic_id=491813
名叫  SiCrane  Staff 的老外回复内容如下：