但是,std::vector确实有一些值得注意的陷阱, 这里先说其中一个, 请看以下代码.

std::vector< int >  values;

values.push_back(1);

values.push_back(2);

values.push_back(3);

values.erase(values.begin() + 1);

乍看之下,这几行简单的代码没什么 问题. 实际执行起来, 还是没什么问题 , 但却有一个陷阱. 由于例子里面用的是int的vector,所以这样做没有任何问题, 但,假如不是一个int, 而是一个类,一个结构体,类或结构体里面还有指针, 那就很可能出问题了. why?

因为vector不象list,vector始终要保持一个完整的内存结构(因为就是一个数组),这样才可以让values[1]这样的方式正确运行. 但是,如果要在vector中间删掉一个成员的话,vector是这样做的, 先把该成员后面的一个成员,一直到最后一个成员往前一位置拷贝,这样需要删除的成员已经被后面的覆盖了, 然后再删除最后一个成员,这样,vector又能保持一段完整的内存结构了.  注意,因为最后一个成员会被删除,而如果这个成员里面有一个成员变量是指针, 那析构函数很有可能会把这个指针指向的地方释放掉!  这样,即使最后一个成员被复制了一份 到倒数第2的位置,也因为在他本身被删除的时候,把倒数第2个(也就是它的复制) 的指针成员所指向的地方给释放了! 如图：

解决的办法也很简单, 最少有2种. 1,  增加作为vector类型的类的拷贝构造函数, 因为vector在erase的时候会发生一次拷贝,让拷贝构造函数不单单是复制指针,还把指针所指向的内容给拷贝一份,这样就不会导致被最后一个成员释放的时候一起释放掉了. 2, 如果有引用记数的话,如智能指针, 就不会被释放掉了。不过如果一般编码里面不需要用到引用记数的话,还是方法1比较简便

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

会，析构函数也会自动调用。  
  但如果存储的是对象的指针，外部对象如果是在堆上分配的，需要我们自已delete

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

STL的容器是基于by   value语意的。当你把一个元素放入容器中，在容器中存放的实际上是这个元素的一个副本（这就是为什么STL容器要求元素必须可以拷贝构造和赋值），副本所占的内存是STL容器自己分配的，所以它会自己回收这些内存，同时调用元素的析构函数。  
  但是如果你把指针放到容器中，clear的时候容器只负责回收指针本身所占的内存，至于指针所指向的东西，它是不管。

·            标准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算法配合，因为指针可以当作数组的迭代器使用。

  二.删除元素

如果想删除东西，记住remove算法后，要加上erase

所谓删除算法，最终还是要调用成员函数去删除某个元素，但是因为remove并不知道它现在作用于哪个容器，所以remove算法不可能真的删除一个元素

1.Vector

vector<int> v;  

v.reserve(10);  

for (int i = 1; i <= 10; ++i) {

v.push_back(i);

}

cout << v.size();   // 10

v[3] = v[5] = v[9] = 99;

remove(v.begin(), v.end(), 99);

//v.erase(remove(v.begin(),v.end(),99),v.end());

cout << v.size();   // 10！

2. list

list<int> listTest;

listTest.remove(99);//这个成员函数将真的删除元素，并且要比erase+remove高效

remove和remove_if之间的十分相似。但unique行为也像remove。它用来从一个区间删除东西（邻近的重复值）而不用访问持有区间元素的容器。如果你真的要从容器中删除元素，你也必须成对调用unique和erase，unique在list中也类似于remove。正像list::remove真的删除东西（而且比erase-remove惯用法高效得多）。list::unique也真的删除邻近的重复值（也比erase-unique高效）。

三 迭代器失效：

一个网友提的问题：

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相同。

string的下面红色代码出错，采用动态库，却没有发现这个问题

template <bool __threads, int __inst>
void* _STLP_CALL
__node_alloc<__threads, __inst>::_M_allocate(size_t __n) {
  void*  __r;
  _Obj * _STLP_VOLATILE * __my_free_list = _S_free_list + _S_FREELIST_INDEX(__n);
  // #       ifdef _STLP_THREADS
  /*REFERENCED*/
  _Node_Alloc_Lock<__threads, __inst> __lock_instance;
  // #       endif
  // Acquire the lock here with a constructor call.
  // This ensures that it is released in exit or during stack
  // unwinding.
  if ( (__r  = *__my_free_list) != 0 ) {
    *__my_free_list = ((_Obj*)__r) -> _M_free_list_link;
  } else {
    __r = _S_refill(__n);
  }

解决办法：

使用动态库的STLPORT

1struct sMem
2{
3    int m_i;
4    sMem(int i = 10)
5    {
6        m_i = i;
7    }
8
9    int GetI()
10    {
11        return m_i;
12    }
13};

1
2typedef vector<sMem*> sMemList;
3typedef vector<sMem*>::iterator sIT;
4sMemList MemList;

1    // 迭代器失效
2    for (sIT it = MemList.begin(); it != MemList.end(); ++it)
3    {
4        if ((*it)->GetI() == 10)
5            MemList.erase(it);
6        else
7        {
8            printf("%d:%d\n", i++, (*it)->GetI());
9        }
10    }

两种解决方法：
对于顺序容器：

bool Equal10(sMem* pMem)
{

    return pMem->GetI() == 10 ? true : false;
}

1MemList.erase(remove_if(MemList.begin(), MemList.end(), Equal10));

对于结点容器：

1    for (sIT it = MemList.begin();
2        it != MemList.end(); )
3    {
4        if ((*it).second->GetI() == 10)
5            MemList.erase(it++);
6        else
7        {
8            printf("%d:%d\n", i++, (*it).second->GetI());
9            it++;
10        }
11    }

名称

功能描述

equal_to

相等

not_equal_to

不相等

less

小于

greater

大于

less_equal

小于等于

greater_equal

大于等于

实例：
//less<int>()默认排序－－升序
//greater<int>()
vector < int > vect;
//...
sort(vect.begin(), vect.end());
//此时相当于调用
sort(vect.begin(), vect.end(), less<int>() );

http://www.stlchina.org/twiki/bin/view.pl/Main/STLSortAlgorithms?sortcol=0;table=2;up=0#sorted_table

int data[32] = {0};

int* pFind = NULL;

if(pFind = std::find_if(data, data + sizeof(data)/sizeof(int), cmp_fun))//---判断找到了

//---- 正确的是

if((data + sizeof(data)/sizeof(int)) != (pFind = std::find_if(data, data + sizeof(data)/sizeof(int), cmp_fun)))//---判断找到了

一、使用静态连接，否则需要stlport的dll

#define _STLP_USE_STATIC_LIB

放到ALT+F7->C++->Preprocessor definitions里面即可（DEBUG和RELEASE都改）

ar << data;

ar & data;

输入档案(archive)类似于输入数据流(stream)。数据能通过>> 或 & 操作符从档案(archive)中装载。

ar >> data;

ar & data;

对于原始数据类型，当这些操作调用的时候，数据是简单的“被存储/被装载” “到/从” 档案(archive)。对于类(class)数据类型，类的serialize 函数被调用。对上面的操作，每个serialize 函数用来“存储/装载”其数据成员。这个处理采用递归的方式，直到所有包含在类中的数据“被存储/被装载”。

一个非常简单的情形

通常用serialize 函数来存储和装载类的数据成员。

这个库包含一个叫 demo.cpp 的程序，用于介绍如何用这个库。下面，我们从这个demo摘录代码，来介绍这个库应用的最简单情形。

#include <fstream>

// include headers that implement a archive in simple text format

#include <boost/archive/text_oarchive.hpp>

#include <boost/archive/text_iarchive.hpp>

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

// gps coordinate

//

// illustrates serialization for a simple type

//

class gps_position

{

private:

    friend class boost::serialization::access;

    // When the class Archive corresponds to an output archive, the

    // & operator is defined similar to <<.  Likewise, when the class Archive

    // is a type of input archive the & operator is defined similar to >>.

    template<class Archive>

    void serialize(Archive & ar, const unsigned int version)

    {

        ar & degrees;

        ar & minutes;

        ar & seconds;

    }

    int degrees;

    int minutes;

    float seconds;

public:

    gps_position(){};

    gps_position(int d, int m, float s) :

        degrees(d), minutes(m), seconds(s)

    {}

};

int main() {

    // create and open a character archive for output

    std::ofstream ofs("filename");

    boost::archive::text_oarchive oa(ofs);

    // create class instance

    const gps_position g(35, 59, 24.567f);

    // write class instance to archive

    oa << g;

    // close archive

    ofs.close();

    // ... some time later restore the class instance to its orginal state

    // create and open an archive for input

    std::ifstream ifs("filename", std::ios::binary);

    boost::archive::text_iarchive ia(ifs);

    // read class state from archive

    gps_position newg;

    ia >> newg;

    // close archive

    ifs.close();

    return 0;

}

对于每个通过序列化“被存储”的类，必须存在一个函数去实现“存储”其所有状态数据。对于每个通过序列化“被装载”的类，必须存在一个函数来实现“装载”其所有状态数据。在上面的例子中，这些函数是模板成员函数serialize。

非侵入的版本

在上例是侵入的设计。类是需要由其实例来序列化，来改变。这在某些情形是困难的。一个等价的可选的设计如下：

#include <boost/archive/text_oarchive.hpp>

#include <boost/archive/text_iarchive.hpp>

class gps_position

{

public:

    int degrees;

    int minutes;

    float seconds;

    gps_position(){};

    gps_position(int d, int m, float s) :

        degrees(d), minutes(m), seconds(s)

    {}

};

namespace boost {

namespace serialization {

template<class Archive>

void serialize(Archive & ar, gps_position & g, const unsigned int version)

{

    ar & g.degrees;

    ar & g.minutes;

    ar & g.seconds;

}

} // namespace serialization

} // namespace boost

这种情况生成的serialize 函数不是gps_position类的成员函数。这有异曲同工之妙。

非侵入序列化主要应用在不改变类定义就可实现类的序列化。为实现这种可能，类必须提供足够的信息来更新类状态。在这个例子中，我们假设类有public成员。仅当提供足够信息来存储和装载的类，才能不改变类自身，在外部来序列化类状态。

可序列化的成员

一个可序列化的类，可拥有可序列化的成员，例如：

class bus_stop

{

    friend class boost::serialization::access;

    template<class Archive>

    void serialize(Archive & ar, const unsigned int version)

    {

        ar & latitude;

        ar & longitude;

    }

    gps_position latitude;

    gps_position longitude;

protected:

    bus_stop(const gps_position & lat_, const gps_position & long_) :

    latitude(lat_), longitude(long_)

    {}

public:

    bus_stop(){}

    // See item # 14 in Effective C++ by Scott Meyers.

    // re non-virtual destructors in base classes.

    virtual ~bus_stop(){}

};

这里，类类型的成员被序列化，恰如原始类型被序列化一样。

注意，类bus_stop的实例“存储”时，其归档(archive)操作符将调用latitude 和 longitude的serialize 函数。这将依次调用定义在gps_position中的serialize 来被“存储”。这种手法中，通过bus_stop的归档(archive)操作符,整个数据结构被存储,bus_stop是它的根条目。

派生类

派生类应包含其基类的序列化。

#include <boost/serialization/base_object.hpp>

class bus_stop_corner : public bus_stop

{

    friend class boost::serialization::access;

    template<class Archive>

    void serialize(Archive & ar, const unsigned int version)

    {

        // serialize base class information

        ar & boost::serialization::base_object<bus_stop>(*this);

        ar & street1;

        ar & street2;

    }

    std::string street1;

    std::string street2;

    virtual std::string description() const

    {

        return street1 + " and " + street2;

    }

public:

    bus_stop_corner(){}

    bus_stop_corner(const gps_position & lat_, const gps_position & long_,

        const std::string & s1_, const std::string & s2_

    ) :

        bus_stop(lat_, long_), street1(s1_), street2(s2_)

    {}

};

注意在派生类中不要直接调用其基类的序列化函数。这样做看似工作，实际上绕过跟踪实例用于存储来消除冗余的代码。它也绕过写到档案中类的版本信息的代码。因此，总是声明serialize 作为私有函数。声明friend boost::serialization::access 将运行序列化库存取私有变量和函数。

指针

假设我们定义了bus route包含一组bus stops。假定：

1. 我们可以有几种bus stop的类型（记住bus_stop是一个基类）。
2. 一个所给的 bus_stop可以展现多于一个的路线。

一个bus route 用一组指向bus_stop的指针来描述是方便的。

class bus_route

{

    friend class boost::serialization::access;

    bus_stop * stops[10];

    template<class Archive>

    void serialize(Archive & ar, const unsigned int version)

    {

        int i;

        for(i = 0; i < 10; ++i)

            ar & stops[i];

    }

public:

    bus_route(){}

};

数组stops 的每个成员将被序列化。但是，记住每个成员是个指针。 - 实际含义是什么？序列化整个对象是要求在另一个地方和时间重新构造原始数据结构。用指针为了完成这些，存储指针的值是不够的，指针指向的对象必须存储。当成员最后被装载，一个新的对象被创建，新的指针被装载到类的成员中。

所有这一切是由序列化库自动完成的。通过指针关联的对象，上述代码能完成存储和装载。

数组

事实上上述方案比较复杂。序列化库能检测出被序列化的对象是一个数组，将产生上述等价的代码。因此上述代码能更短的写为：

class bus_route

{

    friend class boost::serialization::access;

    bus_stop * stops[10];

    template<class Archive>

    void serialize(Archive & ar, const unsigned int version)

    {

        ar & stops;

    }

public:

    bus_route(){}

};

STL容器

上面的例子用数组成员。更多的如此的一个应用用STL容器为如此的目的。序列化库包含为所有STL容器序列化的代码。因此，下种方案正如我们所预期的样子工作。

#include <boost/serialization/list.hpp>

class bus_route

{

    friend class boost::serialization::access;

    std::list<bus_stop *> stops;

    template<class Archive>

    void serialize(Archive & ar, const unsigned int version)

    {

        ar & stops;

    }

public:

    bus_route(){}

};

类的版本

假设我们对bus_route类满意，在产品中使用它。一段时间后，发觉bus_route 类需要包含线路驾驶员的名字。因此新版本如下：

#include <boost/serialization/list.hpp>

#include <boost/serialization/string.hpp>

class bus_route

{

    friend class boost::serialization::access;

    std::list<bus_stop *> stops;

    std::string driver_name;

    template<class Archive>

    void serialize(Archive & ar, const unsigned int version)

    {

        ar & driver_name;

        ar & stops;

    }

public:

    bus_route(){}

};

好，完毕！异常...会发生在读取旧版本所生成的数据文件时。如何考虑版本问题？

通常，序列化库为每个被序列化的类在档案中存储版本号。缺省值是0。当档案装载时，存储的版本号可被读出。上述代码可修改如下：

#include <boost/serialization/list.hpp>

#include <boost/serialization/string.hpp>

#include <boost/serialization/version.hpp>

class bus_route

{

    friend class boost::serialization::access;

    std::list<bus_stop *> stops;

    std::string driver_name;

    template<class Archive>

    void serialize(Archive & ar, const unsigned int version)

    {

        // only save/load driver_name for newer archives

        if(version > 0)

            ar & driver_name;

        ar & stops;

    }

public:

    bus_route(){}

};

BOOST_CLASS_VERSION(bus_route, 1)

对每个类通过应用的版本，没有必要维护一个版本文件。一个文件版本是所有它组成的类的版本的联合。系统允许程序和以前版本的程序创建的档案向下兼容。

把serialize拆分成save/load

serialize函数是简单，简洁，并且保证类成员按同样的顺序（序列化系统的key）被存储/被装载。可是有像这里例子一样，装载和存储不一致的情形。例如，一个类有多个版本的情况发生。上述情形能重写为：

#include <boost/serialization/list.hpp>

#include <boost/serialization/string.hpp>

#include <boost/serialization/version.hpp>

#include <boost/serialization/split_member.hpp>

class bus_route

{

    friend class boost::serialization::access;

    std::list<bus_stop *> stops;

    std::string driver_name;

    template<class Archive>

    void save(Archive & ar, const unsigned int version) const

    {

        // note, version is always the latest when saving

        ar  & driver_name;

        ar  & stops;

    }

    template<class Archive>

    void load(Archive & ar, const unsigned int version)

    {

        if(version > 0)

            ar & driver_name;

        ar  & stops;

    }

    BOOST_SERIALIZATION_SPLIT_MEMBER()

public:

    bus_route(){}

};

BOOST_CLASS_VERSION(bus_route, 1)

BOOST_SERIALIZATION_SPLIT_MEMBER() 宏生成调用 save 或 load的代码，依赖于是否档案被用于“存储”或“装载”。

档案

我们这里讨论将聚焦到类的序列化能力上。被序列化的数据的实际编码实现于档案(archive)类中。被序列化的数据流是所选档案(archive)类的序列化的产物。(键)key设计决定这两个组件的独立性。允许任何序列化的规范可用于任何档案(archive)。

在这篇指南中，我们用了一个档案类-用于存储的text_oarchive和用于装载的text_iarchive类。在库中其他档案类的接口完全一致。一旦类的序列化已经被定义，类能被序列化到任何档案类型。

假如当前的档案集不能提供某个属性，格式，或行为需要特化的应用。要么创建一个新的要么从已有的里面衍生一个。将在后继文档中描述。

注意我们的例子save和load程序数据在一个程序中，这是为了讨论方便而已。通常，被装载的档案或许在或许不在同一个程序中。

T完整的演示程序 - demo.cpp 包括：

1. 创建各种类别的 stops, routes 和 schedules
2. 显示它
3. 序列化到一个名叫 "testfile.txt"的文件中
4. 还原到另一个结构中
5. 显示被存储的结构

这个程序的输出 分证实了对序列化系统所有的要求，都在这个系统中体现了。对序列化文件是ASCII文本的档案文件的内容 能被显示。

vector<TickValue>::iterator iter;
iter = iter + 3;   

//----下面的不可以

list<TickValue>::iterator iter;
iter = iter + 3;   

int main(int argc, char* argv[])
{
    vector<int> vec_test;
    list<int>    lst_test;
    set<int>    set_test;
    int* p_test = &(*vec_test.begin()); //---- NULL
    p_test = &vec_test[0];                //---- NULL
    p_test = &(*lst_test.begin());        //---- 不是NULL
    p_test = (int*)&(*set_test.begin());//---- 不是NULL
    return 0;
}

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

vector的assgin空地址测试，红色部分无法理解

int main(int argc, char* argv[])
{
    vector<int> vec_test;
    size_t s = 0;
    vec_test.assign(NULL, NULL);
    s = vec_test.size();    //---- 0
    vec_test.assign(NULL, NULL + 100);
    s = vec_test.size();    //---- 0
    return 0;
}

如果m_vecSymbolSummary.size() == 0,那么m_vecSymbolSummary.size() - 1将会变成很大数，而产生问题

for (size_t t = 0; t < (m_vecSymbolSummary.size() - 1); ++t)

但是需要容器元素，支持==,或者有<

struct MultiData
{
    int a;
    int b;
   int c;
};

struct ICmpMuls
{
    bool operator()(const MultiData& first, const MultiData& second) const
    {
        if(first.a< second.a)return true;
        if(first.a== second.a)
           if(first.b< second.b)return true;
              if(first.b== second.b)
                 if(first.c< second.c)return true;
        return false;
    }
};

int main(int argc, char* argv[])
{
    vector<MultiData> vec_muls;
    for (int i = 0; i < 300; ++i)
        vec_muls.push_back(MultiData(rand()%20, rand()));
    sort(vec_muls.begin(), vec_muls.end(), ICmpMuls());
    for (size_t s = 0; s < vec_muls.size(); ++s)
        cout<<s<<":     "<<vec_muls[s].login<<" / "<<vec_muls[s].order<<endl;
    return 0;
}

Container<int> c; 

而你想把c中所有值为1963的对象都去掉。令人吃惊的是，完成这项任务的方法因不同的容器类型而不同：没有一种方法是通用的。

如果你有一个连续内存容器（vector、deque或string——参见条款1），最好的方法是erase-remove惯用法（参见条款32）：

c.erase(remove(c.begin(), c.end(), 1963),	// 当c是vector、string
		c.end());			// 或deque时，
						// erase-remove惯用法
						// 是去除特定值的元素
						// 的最佳方法

这方法也适合于list，但是，正如条款44解释的，list的成员函数remove更高效：

c.remove(1963);		// 当c是list时，
			// remove成员函数是去除
			// 特定值的元素的最佳方法

当c是标准关联容器（即，set、multiset、map或multimap）时，使用任何叫做remove的东西都是完全错误的。这样的容器没有叫做remove的成员函数，而且使用remove算法可能覆盖容器值（参见条款32），潜在地破坏容器。（关于这样的破坏的细节，参考条款22，那个条款也解释了为什么试图在map和multimap上使用remove肯定不能编译，而试图在set和multiset上使用可能不能编译。）

不，对于关联容器，解决问题的适当方法是调用erase：

c.erase(1963);		// 当c是标准关联容器时
			// erase成员函数是去除
			// 特定值的元素的最佳方法

这不仅是正确的，而且很高效，只花费对数时间。（序列容器的基于删除的技术需要线性时间。）并且，关联容器的erase成员函数有基于等价而不是相等的优势，条款19解释了这一区别的重要性。

让我们现在稍微修改一下这个问题。不是从c中除去每个有特定值的物体，让我们消除下面判断式（参见条款39）返回真的每个对象：

bool badValue(int x);	// 返回x是否是“bad”

对于序列容器（vector、string、deque和list），我们要做的只是把每个remove替换为remove_if，然后就完成了：

c.erase(remove_if(c.begin(), c.end(), badValue),	// 当c是vector、string
			c.end());			// 或deque时这是去掉
						// badValue返回真
						// 的对象的最佳方法
c.remove_if(badValue);				// 当c是list时这是去掉
						// badValue返回真
						// 的对象的最佳方法

对于标准关联容器，它不是很直截了当。有两种方法处理该问题，一个更容易编码，另一个更高效。“更容易但效率较低”的解决方案用remove_copy_if把我们需要的值拷贝到一个新容器中，然后把原容器的内容和新的交换：

AssocContainer<int> c;				// c现在是一种
...						// 标准关联容器
AssocContainer<int> goodValues;			// 用于容纳不删除
						// 的值的临时容器
remove_copy_if(c.begin(), c.end(),			// 从c拷贝不删除
		inserter(goodValues,		// 的值到
			goodValues.end()),		// goodValues
			badValue);
c.swap(goodValues);				// 交换c和goodValues
						// 的内容

对这种方法的缺点是它拷贝了所有不删除的元素，而这样的拷贝开销可能大于我们感兴趣支付的。

我们可以通过直接从原容器删除元素来避开那笔帐单。不过，因为关联容器没有提供类似remove_if的成员函数，所以我们必须写一个循环来迭代c中的元素，和原来一样删除元素。

看起来，这个任务很简单，而且实际上，代码也很简单。不幸的是，那些正确工作的代码很少是跃出脑海的代码。例如，这是很多程序员首先想到的：

AssocContainer<int> c;
...
for (AssocContainer<int>::iterator i = c.begin();	// 清晰，直截了当
		i!= c.end();			// 而漏洞百出的用于
		++i) {				// 删除c中badValue返回真
	if (badValue(*i)) c.erase(i);		// 的每个元素的代码
}						// 不要这么做！

唉，这有未定义的行为。当容器的一个元素被删时，指向那个元素的所有迭代器都失效了。当c.erase(i)返回时，i已经失效。那对于这个循环是个坏消息，因为在erase返回后，i通过for循环的++i部分自增。

为了避免这个问题，我们必须保证在调用erase之前就得到了c中下一元素的迭代器。最容易的方法是当我们调用时在i上使用后置递增：

AssocContainer<int> c;
...
for (AssocContainer<int>::iterator i = c.begin();	// for循环的第三部分
	i != c.end();				// 是空的；i现在在下面
	/*nothing*/ ){				// 自增
	if (badValue(*i)) c.erase(i++);		// 对于坏的值，把当前的
	else ++i;					// i传给erase，然后
}						// 作为副作用增加i；
						// 对于好的值，
						// 只增加i

这种调用erase的解决方法可以工作，因为表达式i++的值是i的旧值，但作为副作用，i增加了。因此，我们把i的旧值（没增加的）传给erase，但在erase开始执行前i已经自增了。那正好是我们想要的。正如我所说的，代码很简单，只不过不是大多数程序员在第一次尝试时想到的。

现在让我们进一步修改该问题。不仅删除badValue返回真的每个元素，而且每当一个元素被删掉时，我们也想把一条消息写到日志文件中。

对于关联容器，这说多容易就有多容易，因为只需要对我们刚才开发的循环做一个微不足道的修改就行了：

ofstream logFile;					// 要写入的日志文件
AssocContainer<int> c;
...
for (AssocContainer<int>::iterator i = c.begin();	// 循环条件和前面一样
	i !=c.end();){
	if (badValue(*i)){ 
		logFile << "Erasing " << *i <<'\n';	// 写日志文件 
		c.erase(i++);			// 删除元素
	}
	else ++i;
}

现在是vector、string和deque给我们带来麻烦。我们不能再使用erase-remove惯用法，因为没有办法让erase或remove写日志文件。而且，我们不能使用刚刚为关联容器开发的循环，因为它为vector、string和deque产生未定义的行为！要记得对于那样的容器，调用erase不仅使所有指向被删元素的迭代器失效，也使被删元素之后的所有迭代器失效。在我们的情况里，那包括所有i之后的迭代器。我们写i++，++i或你能想起的其它任何东西都没有用，因为没有能导致迭代器有效的。

我们必须对vector、string和deque采用不同的战略。特别是，我们必须利用erase的返回值。那个返回值正是我们需要的：一旦删除完成，它就是指向紧接在被删元素之后的元素的有效迭代器。换句话说，我们这么写：

for (SeqContainer<int>::iterator i = c.begin(); 
	i != c.end();){
	if (badValue(*i)){
		logFile << "Erasing " << *i << '\n'; 
		i = c.erase(i);			// 通过把erase的返回值
	}					// 赋给i来保持i有效
	else
		++i;
}

这可以很好地工作，但只用于标准序列容器。由于论证一个可能的问题（条款5做了），标准关联容器的erase的返回类型是void^[1]。对于那些容器，你必须使用“后置递增你要传给erase的迭代器”技术。（顺便说说，在为序列容器编码和为关联容器编码之间的这种差别是为什么写容器无关代码一般缺乏考虑的一个例子——参见条款2。)

为了避免你奇怪list的适当方法是什么，事实表明对于迭代和删除，你可以像vector/string/deque一样或像关联容器一样对待list；两种方法都可以为list工作。

如果我们观察在本条款中提到的所有东西，我们得出下列结论：

• 去除一个容器中有特定值的所有对象：

  如果容器是vector、string或deque，使用erase-remove惯用法。

  如果容器是list，使用list::remove。

  如果容器是标准关联容器，使用它的erase成员函数。

• 去除一个容器中满足一个特定判定式的所有对象：

  如果容器是vector、string或deque，使用erase-remove_if惯用法。

  如果容器是list，使用list::remove_if。

  如果容器是标准关联容器，使用remove_copy_if和swap，或写一个循环来遍历容器元素，当你把迭代器传给erase时记得后置递增它。

• 在循环内做某些事情（除了删除对象之外）：

  如果容器是标准序列容器，写一个循环来遍历容器元素，每当调用erase时记得都用它的返回值更新你的迭代器。

  如果容器是标准关联容器，写一个循环来遍历容器元素，当你把迭代器传给erase时记得后置递增它。

如你所见，与仅仅调用erase相比，有效地删除容器元素有更多的东西。解决问题的最好方法取决于你是怎样鉴别出哪个对象是要被去掉的，储存它们的容器的类型，和当你删除它们的时候你还想要做什么（如果有的话）。只要你小心而且注意了本条款的建议，你将毫不费力。如果你不小心，你将冒着产生不必要低效的代码或未定义行为的危险。

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

Example

// equal_range example
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

bool mygreater (int i,int j) { return (i>j); }

int main () {
  int myints[] = {10,20,30,30,20,10,10,20};
  vector<int> v(myints,myints+8);                         // 10 20 30 30 20 10 10 20
  pair<vector<int>::iterator,vector<int>::iterator> bounds;

  // using default comparison:
  sort (v.begin(), v.end());                              // 10 10 10 20 20 20 30 30
  bounds=equal_range (v.begin(), v.end(), 20);            //          ^        ^

  // using "mygreater" as comp:
  sort (v.begin(), v.end(), mygreater);                   // 30 30 20 20 20 10 10 10
  bounds=equal_range (v.begin(), v.end(), 20, mygreater); //       ^        ^

  cout << "bounds at positions " << int(bounds.first - v.begin());
  cout << " and " << int(bounds.second - v.begin()) << endl;

  return 0;
}

Output:

bounds ar positions 2 and 5

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

equal_range()

template< class ForwardIterator, class Type >
pair< ForwardIterator, ForwardIterator >
equal_range( ForwardIterator first,                 ForwardIterator last, const Type &value );

//返回pair ，若容器中存在搜索值，第一个返回by lower_bound(); 第二个 by upper_bound(); 

               若容器中不存在搜索值，两个都返回by upper_bound();            template< class ForwardIterator, class Type, class Compare >
pair< ForwardIterator, ForwardIterator >
equal_range( ForwardIterator first,                 ForwardIterator last, const Type &value,                 Compare comp );

#include <algorithm>
#include <vector>
#include <utility>
#include <iostream>
#include<functional>
using namespace std;
/* generates:
      array element sequence after sort:
      12 15 17 19 20 22 23 26 29 35 40 51
      equal_range result of search for value 23:
              *ia_iter.first: 23         *ia_iter.second: 26
      equal_range result of search for absent value 21:
              *ia_iter.first: 22         *ia_iter.second: 22
      vector element sequence after sort:
      51 40 35 29 26 23 22 20 19 17 15 12
      equal_range result of search for value 26:
              *ivec_iter.first: 26       *ivec_iter.second: 23
      equal_range result of search for absent value 21:
              *ivec_iter.first: 20       *ivec_iter.second: 20
      */

int main()
{
      int ia[] = { 29,23,20,22,17,15,26,51,19,12,35,40 };
      vector< int > ivec( ia, ia+12 );
      ostream_iterator< int >     ofile( cout, " " );
      sort( &ia[0], &ia[12] );
      cout << "array element sequence after sort:\n";
      copy( ia, ia+12, ofile ); cout << "\n\n";
      pair< int*,int* > ia_iter;
      ia_iter = equal_range( &ia[0], &ia[12], 23 );
      cout << "equal_range result of search for value 23:\n\t"
           << "*ia_iter.first: "     << *ia_iter.first << "\t"
           << "*ia_iter.second: " << *ia_iter.second << "\n\n";
      ia_iter = equal_range( &ia[0], &ia[12], 21 );
      cout << "equal_range result of search for "
           << "absent value 21:\n\t"
           << "*ia_iter.first: "     << *ia_iter.first << "\t"
           << "*ia_iter.second: " << *ia_iter.second << "\n\n";
      sort( ivec.begin(), ivec.end(), greater<int>() );
      cout << "vector element sequence after sort:\n";
      copy( ivec.begin(), ivec.end(), ofile ); cout << "\n\n";
      typedef vector< int>::iterator iter_ivec;
      pair< iter_ivec, iter_ivec > ivec_iter;
      ivec_iter = equal_range( ivec.begin(), ivec.end(), 26,
                  greater<int>() );
      cout << "equal_range result of search for value 26:\n\t"
           << "*ivec_iter.first: "     << *ivec_iter.first << "\t"
           << "*ivec_iter.second: " << *ivec_iter.second
         ;
      ivec_iter = equal_range( ivec.begin(), ivec.end(), 21,
                  greater<int>() );
      cout << "equal_range result of search for "
           << "absent value 21:\n\t"
           << "*ivec_iter.first: "     << *ivec_iter.first << "\t"
           << "*ivec_iter.second: " << *ivec_iter.second
           ;
}

       因为 C++语言已经于1998年被标准化，C++的中坚分子在试图推动程序员从数组转到vector时就没什么顾虑了。同样的情况也发生于从char *指针转到string对象的过程中。有很好的理由来做这些转变，比如可以消除常见的编程错误（Item 13），和有机会获得STL泛型算法的全部强大能力 (参见，比如，Item 31)。

       但是，麻烦还是有的，而最常见的一个就是已经存在的传统C风格API函数接受的是数组和char *指针，而不是vector和string对象。这样的API函数还将会存在很长时间，如果我们要高效使用STL的话，就必须和它们和平共处。

       幸运的是，这很容易。如果你有一个vector对象v，而你需要得到一个指向v中数据的指针，以使得它可以被当作一个数组，只要使用&v[0]就可以了。对于string对象s，相应的语法是很简单的s.c_str()。但只能从上面读。如广告时常指明的，有几个限制。。

给定一个

vector<int> v;

       表达式v[0]生产一个指向vector中首元素的引用，所以，&v[0]是指向那个首元素的指针。vector中的元素被C++标准限定为存储在连续内存中，就象是一个数组，所以，如果我们传递v给如此形式的C风格API函数

void doSomething(const int* pInts, size_t numInts);

       我们可以这么做：

doSomething(&v[0],v.size());

       也许吧。可能吧。唯一的问题就是，如果v是空的。如果这样的话，v.size()是0，而&v[0]试图产生一个指向根本就不存在的东西的指针。这不是件好事。其结果未定义。一个较安全的方法是这样：

if (!v.empty()) {

doSomething(&v[0], v.size());

}

       如果走得不对路，你可能会碰到些半瓶子的人物，他们会告诉你说可以用v.begin()代替&v[0]，因为(这些讨厌的家伙将会告诉你)begin()返回指向vector内部的iterator，而对于vector，其iterators实际上是指针。那经常是正确的，但如Item 50所说，并不总是如此，你不该依赖于此。begin()的返回类型是iterator，而不是一个指针，当你需要一个指向vector内部数据的指针时绝不该使用begin()。如果你基于某些原因决定键入v.begin()，就键入&*v.begin()， 因为这将会产生和&v[0]相同的指针，虽然它让你有更多的击键工作且让代码读起来更晦涩。坦白地说，如果你正被告诉你使用v.begin()代替&v[0]的人围绕的话，你该重新考虑一下你的社交圈了。

       类似的从vector上获取指向内部数据的指针的方法，对string是不可靠的，因为

       (1) string中的数据并没有承诺被存储在连续内存中，

       (2)string的内部表示形式并没承诺以一个空字符结束。

       这解释了string的成员函数c_str()存在的原因，它返回一个按C风格设计指针，指向string的值（which returns a pointer to the value of the string in a form designed for C）。 我们可以如此传递一个string对象s给这个函数，

void doSomething(const char *pString);

       就象这样：

doSomething(s.c_str());

       即使是字符串的长度为0，它都能工作。在那种情况下，c_str()将返回一个指向结束符的指针。即使字符串内部自己存在结束符时，它同样能工作。然而，如果真的这样，doSomething很可能将第一个结束符解释为字符串结束。string对象不在意是否容纳了结束符，但基于char *的C风格API函数在意。

       再看一下doSomething()的申明：

void doSomething(const int* pInts, size_t numInts);

void doSomething(const char *pString);

       在两种形式下，指针都被传递为指向const的指针。vector和string的数据被传给只读取而不修改它们的API函数。到目前为止都做的是最安全的事情。对于string，这也是唯一可做的，因为没有承诺说c_str()产生的指针指在string数据的内部表示形式上；它可以返回一个指针指向数据的一个不可修改的拷贝，这个拷贝满足C风格API函数对格式的要求。（如果这个恐吓令你寒毛都立起来的话，还请宽心，因为它也许不成立。我没听说目前哪个运行库的实现是使用了这个自由权的。）

       对于vector，有更多一点点灵活性。如果你将v传给一个修改其元素的C风格API函数的话，典型情况都是没问题，但被调用的函数绝不能试图改变vector中元素的个数。比如，它绝不能试图在vector还未使用的容量（capacity）上“创建”新的元素。如果这么干了，v将会变得内部状态不一致，因为它再也不知道自己的正确大小（size）了。v.size()将会得到一个不正确的结果。并且，如果被调用的函数试图在一个大小和容量（见Item 14）相等的vector上追加数据的话，真的会发生灾难性事件。我甚至根本就不愿去想象它。实在太可怕了。

       你注意到我在前面用的是“典型地”一词吗？你当然注意到了。有些vector对其数据有些额外的限制，你一定要确保这些额外限制继续被满足。举个例子，Item 23解释了排序的vector常用来实现关联容器，但对这些vector而言，保持排序非常重要。如果你将一个排序的vector传给一个可能修改其数据的API函数，你需要重视vector在调用返回后不再保持排序的情况。

       如果你想用C风格API函数返回的元素初始化一个vector，你可以利用vector和数组内在的相容性，通过将存储vecotr的元素的空间传给API函数：

// C API: this function takes a pointer to an array of at most arraySize

// doubles and writes data to it. It returns the number of doubles written,

// which is never more than maxNumDoubles.

size_t fillArray(double *pArray, size_t arraySize);

vector<double> vd(maxNumDoubles); // create a vector whose

// size is maxNumDoubles

vd.resize(fillArray(&vd[0], vd.size())); // have fillArray write data

// into vd, then resize vd

// to the number of

// elements fillArray wrote

       这个技巧只能工作于vector，因为只有vector承诺了与数组具有相同的内在内存分布。但是，如果你想用来自C风格API函数的数据初始化string对象，你可以做得足够简单。只要让API函数将数据放入一个vector<char>，然后从vector中将数据拷到string:

// C API: this function takes a pointer to an array of at most arraySize

// chars and writes data to it. It returns the number of chars written,

// which is never more than maxNumChars.

size_t fillString(char *pArray, size_t arraySize);

vector<char> vc(maxNumChars); // create a vector whose

// size is maxNumChars

size_t charsWritten = fillString(&vc[0], vc.size()); // have fillString write

// into vc

string s(vc.begin(), vc.begin()+charsWritten); // copy data from vc to s

// via range constructor

// ( see Item 5)

       事实上，这个主意总是有效的：让C风格API函数将数据放入一个vector，然后拷到你实际想要的STL容器中。

size_t fillArray(double *pArray, size_t arraySize); // as above

vector<double> vd(maxNumDoubles); // also as above

vd.resize(fillArray(&vd[0], vd.size());

deque<double> d(vd.begin(), vd.end()); // copy data into

// deque

list<double> l(vd.begin(), vd.end()); // copy data into list

set<double> s(vd.begin(), vd.end()); // copy data into set

       此外，这也提示了vector和string以外的STL容器如何将它们的数据传给C风格API函数。只要将容器的每个数据拷到vector，然后将它们传给API函数：

void doSomething(const int* pInts, size_t numInts); // C API (from above)

set<int> intSet; // set that will hold

... // data to pass to API

vector<int> v(intSet.begin(), intSet.end()); // copy set data into

// a vector

if (!v.empty()) doSomething(&v[0], v.size()); // pass the data to

// the API

       你也可以将数据拷进一个数组，然后将数组传给C风格的API，但你为什么想这样做？除非你在编译期就知道容器的大小，否则你不得不分配动态数组，而Item 13解释了为什么你应该总是使用vector来取代动态分配的数组。

********************************************
如果和PlatformSDK 一起使用的话
要记的在STLport目录中 \stlport\stl_user_config.h 文件中
把这一句打开

     # define _STLP_NEW_PLATFORM_SDK 1

否则在编译时会有如下错误
second C linkage of overloaded function 'InterlockedIncrement' not allowed

********************************************

如果想静态链接 STLPort 请在VC6的 C/C++ \ General \ Preprocessor definitions
中添加宏 _STLP_USE_STATIC_LIB

********************************************

对於使用IOSTREAM的, 如果有问题
在STLport目录中 \stlport\stl_user_config.h 文件中
把这一句打开吧

    # define _STLP_NO_IOSTREAMS 1

********************************************

- When you erase an element from a hash_map only iterators to the erased element are invalidated
  so you can write something like:

while (it != myHashMap.end()) {
if (condition)
myHashMap.erase(it++); //这里为何这样不出错 而把it++放外面就不行呢
    //在外面是对删除后的无效指针加, 而里面是对有效指针加
else
++it;
}

  To finish STLport has a special debug mode to check such bad construction. Check the
  stl_user_config.h file in the stlport folder for that, the macro is _STLP_DEBUG.

1 Boost 安装简介

在正式开始使用 Boost.Python 之前， 我们必须先编译 Boost。 首先到 Boost 的官方站点 下载 Boost 的源码包， 把它们解压到你喜欢的目录，为编译做好准备。 另外， 在正式安装 Boost.Python 之前， 我们必须先正确安装 Python。

1.1 Linux 下的编译

首先切换到 Boost 源码所在的路径， 执行 ./configure 脚本，为配置脚本提供 Python 运行环境相应的参数：

./configure --with-python=/usr/bin/python \
            --with-python-version=2.4 \
            --with-python-root=/usr

然后， 和绝大部分 Linux 程序一行， 执行 make 就可以开始编译了。编译完毕后， 切换到 root 权限后再执行 make install，把 Boost 相应的头文件和库文件复制到相应的地方， 就可以使用了。

1.2 使用 MinGW + MSys 在 Windows 下的编译

首先需要编译的是 Boost 的编译工具 bjam， 直接到 bjam 所在目录下， 即 Boost 源码包所在目录下的 \tools\build\jam_src， 执行 build.bat mingw，稍等片刻， bjam.exe 就编译好了。 把编译好的 bjam.exe 复制到你的 %PATH% 路径能够直接找到的地方， 为后续的编译工作做好准备。

接下来， 切换到 Boost 源码所在路径， 执行 bjam 进行编译。 我们需要提供关于 Python 的一些参数， 变量 PYTHON_ROOT 指向 Python 运行环境所在的目录，变量 PYTHON_VERSION 的值为 Python 的版本号， 如果你的 Python 安装路径与滇狐不同，请将相应的变量修改为你机器上相应的路径， 编译命令行如下：

bjam.exe "-sTOOLS=mingw" "-sPYTHON_ROOT=E:\Python" "-sPYTHON_VERSION=2.4"

编译完毕后， 你将会在你的 C:\Boost 下找到编译得到的 Boost 相应头文件与库文件， 你可以根据你的需要将它移动到别的地方备用。

2 使用 Boost.Python 嵌入 Python 模块到 C++

Boost.Python 目前并没有提供完整的将 Python 模块嵌入到 C++ 的包装库，因此许多工作我们还必须通过 Python C API 来进行。 但是， 利用 Boost.Python 中提供的一些模块， 能够给我们的工作带来极大便利。

2.1 修改模块加载路径，装入 Python 模块

与任何一个其它 Python 嵌入 C/C++ 的程序一样， 我们需要在第一条 #include 语句处含入 Python.h， 并在程序开始时调用 Py_Initialize()，在程序结束时调用 Py_Finalize()。

接下来， 我们便可以开始准备装入 Python 模块了。 为了让 Python 解释器能够正确地找到 Python 模块所在的位置， 我们需要将 Python 模块所在的路径添加到模块搜索路径中，添加搜索路径的 Python 语句如下：

import sys
if not '/module/path' in sys.path:
    sys.path.append('/module/path')

我们使用 Python C API 执行类似的语句， 就能将模块的搜索路径添加到 Python 解释器中。 添加了搜索路径后， 就可以通过 PyImport_ImportModule 函数加载 Python 模块了。 PyImport_ImportModule 返回值是 PyObject *， 为了避免手工处理繁琐的引用计数等问题，我们求助于 Boost.Python 提供的 handle 模块， 将 PyObject * 封装起来， 以方便使用， 代码如下：

#include <boost/python.hpp>

...

    boost::python::handle<>* _module; // Module handle.
    std::string path; // Path of the Python module.
    std::string module; // Module name.

...

    try
    {
        PyRun_SimpleString("import sys");
        PyRun_SimpleString((std::string("if not '") + path
            + "' in sys.path: sys.path.append('" + path + "')").c_str());
        _module = new boost::python::handle<>(
            PyImport_ImportModule((char *) module));
        ...
    }
    catch (...)
    {
        PyErr_Print();
        PyErr_Clear();
        delete _module;
        _module = NULL;
        return false;
    }

...

需要注意的是， 通过 Python C API 加载的 Python 解释器并没有把当前路径列入默认的搜索路径中。因此， 即使你的 Python 模块就存放在当前路径， 你也必须使用上面的代码将当前路径添加到搜索路径中之后，才能通过 PyImport_ImportModule 加载到模块。

当 Python 模块使用完毕或程序结束时， 请使用 delete 将 _module 指针释放， handle 被释放的时候会自动释放相应的 Python 模块并回收相应资源。

2.2 调用 Python 函数

导入了 Python 模块之后， 调用 Python 函数就非常容易了。 Boost.Python 里封装了一个非常好用的模板函数 boost::python::call_method，它可以替你处理调用函数时需要处理的种种细节， 将你从 Python C API 中繁琐的“将参数打包为 PyObject *”、 “构造 Tuple”、 “传递 Tuple”、 “解包返回值”等工作中彻底解放出来， 你只需要这样：

    boost::python::call_method<返回值类型>(模块指针, "Python 函数名",
        参数 1, 参数 2, ...);

模块指针可以通过我们前面得到的 _module 的 get 方法获得， 例如：

...
    bool result;
    std::string config_file;

    ...

    try
    {
        return boost::python::call_method<bool>(_module->get(), "initialize",
            config_file);
    }
    catch (...)
    {
        PyErr_Print();
        PyErr_Clear();
        ...
    }

...

2.3 使用 Python 类对象

使用 Python C API 调用 Python 函数和调用 Python 类对象是没有太大区别的，我们只需要调用类的构造方法， 得到一个类对象， 然后把该类的指针看做模块指针，按照前面调用普通函数的方法调用类成员方法就可以了。 例如， 下列代码从 _module 中创建了一个 YukiSession 对象， 然后调用了其中的 on_welcome 方法。 除了展示调用类成员方法外， 这段代码还展示了构造 Python list 对象、 从 Python list 对象中获取元素的方式。

    ...

    boost::python::handle<> _yukisession;

    ...

    // Retrieve the module handle and namespace handle.
    boost::python::object main_module(*_module);
    boost::python::object main_namespace = main_module.attr("__dict__");

    // Call the method and get the object handle.
    _yukisession = boost::python::handle<>((PyRun_String(
        "YukiSession()", Py_eval_input,
        main_namespace.ptr(), main_namespace.ptr())));
    ...

    // Compose a list.
    boost::python::list param;
    param.append(boost::python::str(_addr.get_host_addr()));
    param.append(boost::python::str());

    // Call the method and retrieve the result.
    // Method is equivalent to:
    // "bool __thiscall YukiSession::on_welcome(list param);"
    result = boost::python::call_method<bool>
        (_yukisession.get(), "on_welcome", param);
    // Extract an item from a list.
    str = boost::python::call_method<std::string>
        (param.ptr(), "__getitem__", 1);

    ...

3 在嵌入的 Python 模块中调用 C++ 程序

通过动态链接库的方式使用 Boost.Python 导出 C++ 模块到 Python 程序与在 C++ 可执行程序中导出模块给嵌入的 Python 解释器， 编写程序的方式几乎是完全相同的。因此这里只简单介绍导出普通函数的方法， 想详细了解更多高级功能， 如导出 C++ 类、 导出可被 Python 重载的类等， 可以参看华宇煜的 Boost.Python 简明教程或官方 Boost.Python 文档。

3.1 导出 C++ 函数

首先使用 BOOST_PYTHON_MODULE 宏定义需要导出给 Python 的模块，然后用 boost::python::def 语句定义导出的函数、 参数列表以及 Doc String， 例如在下面的例子中， 我们导出了一个 C++ 函数 yukigettext，并重命名为 gettext：

const char *yukigettext(const char *id);

BOOST_PYTHON_MODULE(yuki)
{
    boost::python::def("gettext", yukigettext,
        boost::python::args("id"), "Translate message.");
}

3.2 为 Python 初始化 C++ 模块

使用 BOOST_PYTHON_MODULE(name) 定义了 Python 模块后，该宏会自动生成一个函数 initname， 我们需要在 Py_Initialize() 之后调用这个自动生成的函数， 初始化导出到 Python 的模块。 例如我们刚才导出模块用的宏 BOOST_PYTHON_MODULE(yuki)， 因此初始化的时候就应该调用 inityuki()：

...
    Py_Initialize();
    inityuki();
...

3.3 在 Python 模块中调用 C++ 模块

此时我们在 Python 模块中只需要像普通的 Python 模块那样， 将导入的 C++ 模块用 import 语句加载进来， 就可以调用了：

import yuki

...

print yuki.gettext("This is a test!")

1. 如何将字符串"123"转换为int类型整数123？答案是，用标准C的库函数atoi；
2. 如果要转换为long类型呢？标准C的库函数atol；
3. 如何将"123.12"转换为double类型呢？标准C的库函数atod；
4. 如果要转换为long double类型呢？标准C的库函数atold；
5. ……

后来有朋友开始使用标准库中的string类，问这个如何转换为数值？有朋友答曰，请先转换为const char*。我很佩服作答者有数学家的思维：把陌生的问题转化成熟悉的问题。（曾经有一则笑话，好事者问数学家：知道如何烧水吗？答：知道。把水壶加满水，点火烧。又问：如果水壶里已经有水了呢？答：先倒掉，就转化为我熟悉的问题了……）

不，不，这样是C的做法，不是C++。那么，C++该怎么做呢？使用Boost Conversion Library所提供的函数lexical_cast（需要引入头文件boost/lexical_cast.hpp）无疑是最简单方便的。如：

#include <boost/lexical_cast.hpp>
#include <iostream>
int main()
{
        using boost::lexical_cast;
        int a = lexical_cast<int>("123");
        double b = lexical_cast<double>("123.12");
        std::cout<<a<<std::endl
        std::cout<<b<<std::endl;
        return 0;
}

一个函数就简洁地解决了所有的问题。

3.2 数值→字符串

那么从数值类型到字符串类型呢？

用itoa？不对吧，标准C/C++里根本没有这个函数。即使在Windows平台下某些编译器提供了该函数3，没有任何移植性不说，还只能解决int类型（也许其他函数还可以解决long、unsigned long等类型），浮点类型又怎么办？当然，办法还是有，那就是：sprintf。

char s[100];
sprintf(s, "%f", 123.123456);

不知道诸位对C里的scanf/printf系列印象如何，总之阿炯我肯定记不住那些稀奇古怪的参数，而且如果写错了参数，就会得到莫名其妙的输出结果，调试起来可就要命了（我更讨厌的是字符数组，空间开100呢，又怕太小装不下；开100000呢，总觉得太浪费，心里憋气，好在C++标准为我们提供了string这样的字符串类）。这时候，lexical_cast就出来帮忙啦。

#include <boost/lexical_cast.hpp>
#include <string>
#include <iostream>
int main()
{
        using std::string;
        const double d = 123.12;
        string s = boost::lexical_cast<string>(d);
        std::cout<<s<<std::endl;
        return 0;
}

跟前面一样简单。

3.3 异常

如果转换失败，则会有异常bad_lexical_cast抛出。该异常类是标准异常类bad_cast的子类。

#include <boost/lexical_cast.hpp>
#include <iostream>
int main()
{
        using std::cout;
        using std::endl;
        int i;
        try{
                i = boost::lexical_cast<int>("abcd");
        }
        catch(boost::bad_lexical_cast& e)
        {
                cout<<e.what()<<endl;
                return 1;
        }
        cout<<i<<endl;
        return 0;
}

显然“abcd”并不能转换为一个int类型的数值，于是抛出异常，捕捉后输出“bad lexical cast: source type value could not be interpreted as target”这样的信息。

3.4 注意事项

lexical_cast依赖于字符流std::stringstream（会自动引入头文件4），其原理相当简单：把源类型读入到字符流中，再写到目标类型中，就大功告成。例如

int d = boost::lexical_cast<int>("123");

就相当于

int d;
std::stringstream s;
s<<"123";
s>>d;

既然是使用了字符流，当然就有些随之而来的问题，需要特别指出5。

• 由于Visual C++ 6的本地化（locale）部分实现有问题，因此如果使用了非默认的locale，可能会莫名其妙地抛出异常。当然，一般情况下我们并不需要去改变默认的locale，所以问题不是很大。
• 输入数据必须“完整”地转换，否则抛出bad_lexical_cast异常。例如

int i = boost::lexical_cast<int>("123.123"); // this will throw 

便会抛出异常。因为“123.123”只能“部分”地转换为123，不能“完整”地转换为123.123。

• 浮点数的精度问题。

std::string s = boost::lexical_cast<std::string>(123.1234567);

以上语句预想的结果是得到“123.1234567”，但是实际上我们只会得到“123.123”，因为默认情况下std::stringstream的精度是6（这是C语言程序库中的“前辈”printf留下的传统）。这可以说是boost::lexical_cast的一个bug。怎么办呢？权宜之计，可以这么做：打开头文件<boost/lexical_cast.hpp>，注意对照修改6：

#include <boost/limits.hpp>
//...
template<typename Target, typename Source>
Target lexical_cast(Source arg) {
        //...
        Target result; 
        interpreter.precision(std::numeric_limits<Source>::digits10);
        if( !(interpreter << arg) ||
        !(interpreter >> result) ||
        !(interpreter >> std::ws).eof())
        //...
}

即可得到正确结果。当然，理论上效率会有一点点损失，不过几乎可以忽略不计。

4 小结

STLPort 5.1.5 下载

http://sourceforge.net/project/showfiles.php?group_id=146814

Bat文件

cd c:\Program Files\Microsoft Visual Studio\VC98\bin
pause

call VCVARS32.BAT
pause

rem cd C:\STLport-5.1.5\STLport-5.1.5\build\Makefiles\nmake
cd C:\STLport-5.1.5\STLport-5.1.5\build\lib
pause
call configure --help
pause
call configure -c msvc6
pause
nmake /f msvc.mak
nmake /f msvc.mak install

rem nmake -f vc6.mak clean all
rem nmake -f vc6.mak install

pause
exit

rem 版本：boost 1.33.1 STLport 5.0 / VS.net 2003 没有特殊设置，除了程序的debug build应加_STLP_DEBUG宏定义。
rem boost build procedure:
SET INCLUDE=\"D:\\STLport_50\\stlport\";%INCLUDE%
SET LIB=\"D:\\STLport_50\\lib\";%LIB%

SET PYTHON_ROOT=\"D:\\Python24\"
SET PYTHON_VERSION=2.4.2
SET STLPORT_PATH=\"D:\\\"
SET STLPORT_50_PATH=\"D:\\STLport_50\"
SET STLPORT_VERSION=5.0
SET STLPORT_VERSIONS=5.0
SET VC71_ROOT=\"d:\\Program Files\\Microsoft Visual Studio .NET 2003\\Vc7\"

bjam.exe -sBOOST_ROOT=. -sTOOLS=vc-7_1 stage
bjam.exe -sBOOST_ROOT=. -sTOOLS=vc-7_1-stlport stage

如果不编译python库，最后两行改成

bjam.exe -sBOOST_ROOT=. -sTOOLS=vc-7_1 --without-python stage
bjam.exe -sBOOST_ROOT=. -sTOOLS=vc-7_1-stlport --without-python stage

pause
cd c:\boost_1_33_1
pause
rem bjam -sBOOST_ROOT=. -sTOOLS=msvc "-sBUILD=debug release static/dynamic
pause
cd C:\Program Files\Tencent\TM
pause
start TMShell.exe
pause

http://sourceforge.net/project/showfiles.php?group_id=7586&package_id=8041

bat文件，boost 1.33.1 Python 2.2.1,可能需要重新安装stl port, stl port版本有问题 

::如果不要编译bjam.exe的话
rem GOTO install

cd C:\boost_1_33_1\tools\build\jam_src
pause
call build.bat
pause
copy C:\boost_1_33_1\tools\build\jam_src\bin.ntx86\bjam.exe C:\boost_1_33_1
pause

:install

rem SET INCLUDE=\"C:\\STLport-4.6.2\\stlport\";%INCLUDE%
rem SET LIB=\"C:\\STLport-4.6.2\\lib\";%LIB%
SET MSVC_ROOT="C:\Program Files\Microsoft Visual Studio\VC98"
SET VISUALC="C:\Program Files\Microsoft Visual Studio\VC98"
SET JAM_TOOLSET=VISUALC
SET PYTHON_ROOT=C:\Python22
SET PYTHON_VERSION=2.2
SET STLPORT_PATH=C:\STLport-4.6.2\lib
SET STLPORT_VERSION=4.6.2
cd c:\Program Files\Microsoft Visual Studio\VC98\bin
pause

call VCVARS32.BAT
pause

cd C:\boost_1_33_1
pause

::stage代表 lib
::msvc-stlport是msvc-stlport-tools.jam文件，可以搜索得到
::--with-thread是只编译thread库，--without-thread则相反
::比如编译thread 的lib库如下行.
rem bjam -sBOOST_ROOT=. -sTOOLS=msvc --with-thread stage

::编译所有
bjam -sBOOST_ROOT=. -sTOOLS=msvc-stlport install
bjam -sBOOST_ROOT=. -sTOOLS=msvc install

::编译regex
rem bjam -sBOOST_ROOT=. -sTOOLS=msvc-stlport --with-regex install
rem bjam -sBOOST_ROOT=. -sTOOLS=msvc --with-regex install

::编译thread
rem bjam -sBOOST_ROOT=. -sTOOLS=msvc-stlport --with-thread install
rem bjam -sBOOST_ROOT=. -sTOOLS=msvc --with-thread install

pause
exit

1、下载python-2.5.2.msi安装到C:\Python25

http://www.python.org/ftp/python/2.5.2/python-2.5.2.msi

2、下载boost_1_35_0，解压到C:\boost_1_35_0

http://sourceforge.net/project/downloading.php?group_id=7586&use_mirror=nchc&filename=boost_1_35_0.zip&48604828

3、执行C:\boost_1_35_0\tools\jam\build_dist.bat

4、生成了bjam.exe在：C:\boost_1_35_0\tools\jam\src\bin.ntx86\bjam.exe

5、拷贝bjam.exe到C:\boost_1_35_0

6、打开cmd，执行：cd C:\boost_1_35_0

7、执行bjam --toolset=msvc -sPYTHON_ROOT="{C:\Python25}" install

bjam --toolset=msvc-6.0 stdlib=stlport -sPYTHON_ROOT="{C:\Python25}" install

等待半个小时左右

8、将C:\boost_1_35_0\libs文件夹（里面是源代码，lib_source），拷贝到C:\Boost，并更改名为boost_src,这样就成了C:\Boost\boost_src

9、把C:\Boost\include\boost-1_35_0\boost，加入到VC6的Include路径,hpp也是C++的头文件啊！Boost库就是用的这个。

10、将C:\Boost\include\boost-1_35_0\boost和C:\Boost\boost_src，加入到VC6的source路径

11、把C:\Boost\lib，加入到VC6的LIB路径

12、C:\boost_1_35_0这个文件夹可以删除了，如果不想删除，那么C:\boost_1_35_0\bin.v2这个是编译时候的obj等文件，可以删除掉。

运行出现的错误

1、预定义头要加入：,D_STLP_DEBUG,__STL_DEBUG

2、ZM limit 错误：工程->设置->C/C++选项卡下面有“工程选项”的一个命令区在命令行的末尾加上/Zm1000，改为/Zm2000也行，是整百的都可以

3、“compiler   is   out   of   heap   space”，\ZM改成2000(最大了)

4、“Fatal   Error   C1063”，这个错误是编译器栈溢出，可能是你的程序单个源文件太大了，拆分成小一些的文件试试  
      MSDN上：  
      Fatal   Error   C1063  
     compiler   limit   :   compiler   stack   overflow  
      The   program   was   too   complex,   possibly   due   to   recursive   include   files.   Split   the   code   into   smaller   source   files   and   recompile.

手动编译boost::regex

1、cmd;

2、cd C:\boost_1_35_0\libs\regex\build

3、vcvars32.bat

4、SET STLPORT_PATH=C:\STLport\lib(如果需要以STLPort编译的话)

5、nmake -f vc6-stlport.mak（STLPort编译）或者 nmake -f vc6.mak（普通编译）

用来测试的代码，建立一个Win32 Console Application：

#include "stdafx.h"
#include <iostream>
#include <boost/regex.hpp>
#include <boost/thread.hpp>
int main()
{ 
    // 3 digits, a word, any character, 2 digits or "N/A", 
    // a space, then the first word again
    boost::regex reg("\\d{3}([a-zA-Z]+).(\\d{2}|N/A)\\s\\1");   
    std::string correct="123Hello N/A Hello"; 
    std::string incorrect="123Hello 12 hello";   
    assert(boost::regex_match(correct,reg)==true); 
    assert(boost::regex_match(incorrect,reg)==false);
    boost::regex reg1("(new)|(delete)");
    boost::smatch m;std::string s=  "Calls to new must be followed by delete. \  Calling simply new results in a leak!";
    if (boost::regex_search(s,m,reg1))
    {  // Did new match? 
        if (m[1].matched)   
            std::cout << "The expression (new) matched!\n"; 
        if (m[2].matched)   
            std::cout << "The expression (delete) matched!\n";
    }
    return 0;
}

如果一切顺利通过，恭喜你，boost安装成功。

vc6 上安装stlport和boost库

1
vc 6   sp5补丁  预处理补丁
python2.2.3
stlport4.5.3
boost1.3.0.2
2
使用stlport的iostream，boost.python编译失败
如果禁用stlportt的iostream，boost.regex编译失败
选择boost1.3.0.2的原因:
从
http://engineering.meta-comm.com/boost.aspx
得知Boost-wide regression reports
vc6基本支持boost1.3.0.2 的全部库
而boost以后的版本，vc6 的表现可以说是惨不忍睹。
boost1.3.0.2支持 python2.2 stlport 4.5.3
基本就是这个样子了。