亚洲欧美日韩综合一区,亚洲视频中文,亚洲欧洲在线播放

肥仔 — Wed, 02 Sep 2009 14:36:00 GMT

在��?span lang="EN-US">std的容器的时�?span lang="EN-US">,不少人喜�Ƣ用vector, 因�ؓ比�vlist,更省�I�间,而且可以�Ҏ(gu��)��index直接��d��某个�?span lang="EN-US">,而不用一个个枚�D来取.

但是,std::vector��实有一些值得注意的陷�?span lang="EN-US">, �q�里先说其中一�?span lang="EN-US">, ��L��以下代码.

std::vector< int > values;

values.push_back(1);

values.push_back(2);

values.push_back(3);

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

乍看之下,�q�几行简单的代码没什�?问题. 实际执行��h��, �q�是没什么问�?span lang="EN-US"> , 但却有一个陷�?span lang="EN-US">. �׃��例子里面用的�?span lang="EN-US">int�?span lang="EN-US">vector,所以这样做没有��M��问题, �?span lang="EN-US">,假如不是一�?span lang="EN-US">int, 而是一个类,一个结构体,�c�L��l�构体里面还有指�?span lang="EN-US">, 那就很可能出问题�?span lang="EN-US">. why?

因�ؓvector不象list,vector始终要保持一个完整的内存�l�构(因�ؓ��是一个数�l?span lang="EN-US">),�q�样才可以让values[1]�q�样的方式正��运�?span lang="EN-US">. 但是,如果要在vector中间删掉一个成员的�?span lang="EN-US">,vector是这样做�?span lang="EN-US">, 先把该成员后面的一个成�?span lang="EN-US">,一直到最后一个成员往前一位置拯��,�q�样需要删除的成员已经被后面的覆盖�?span lang="EN-US">, 然后再删除最后一个成�?span lang="EN-US">,�q�样,vector又能保持一�D�完整的内存�l�构�?span lang="EN-US">. 注意,因�ؓ最后一个成员会被删�?span lang="EN-US">,而如果这个成员里面有一个成员变量是指针, 那析构函数很有可能会把这个指针指向的地方释放�?span lang="EN-US">! �q�样,即��最后一个成员被复制了一�?span lang="EN-US"> 到倒数�W?span lang="EN-US">2的位�|?span lang="EN-US">,也因为在他本�w�被删除的时�?span lang="EN-US">,把倒数�W?span lang="EN-US">2�?span lang="EN-US">(也就是它的复�?span lang="EN-US">) 的指针成员所指向的地方给释放�?span lang="EN-US">! 如图�Q?span lang="EN-US">

解决的办法也很简�?span lang="EN-US">, 最��有2�U?span lang="EN-US">. 1, 增加作�ؓvector�c�d��的类的拷贝构造函�?span lang="EN-US">, 因�ؓvector�?span lang="EN-US">erase的时候会发生一�ơ拷�?span lang="EN-US">,让拷贝构造函��C��单单是复制指�?span lang="EN-US">,�q�把指针所指向的内容给拯��一�?span lang="EN-US">,�q�样��׃��会导致被最后一个成员释攄��时候一起释放掉�?span lang="EN-US">. 2, 如果有引用记数的�?span lang="EN-US">,如智能指�?span lang="EN-US">, ��׃��会被释放掉了。不�q�如果一般编码里面不需要用到引用记数的�?span lang="EN-US">,�q�是�Ҏ(gu��)��1比较��?span lang="EN-US">

肥仔 2009-09-02 22:36 发表评论

肥仔 — Wed, 02 Sep 2009 14:23:00 GMT

请问如果我在STL容器存储的是对象�Q�那么我在调用clear()或eara()的时候，会自动释放这个对象的内存�I�间吗？会执行该对象的析够函数吗�Q?/font>

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

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

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

STL的容器是��Z��by value语意的。当你把一个元素放入容器中�Q�在容器中存攄��实际上是�q�个元素的一个副本（�q�就是�ؓ什么STL容器要求元素必须可以拯��构造和赋�?/u>�Q�，副本所占的内存是STL容器自己分配的，所以它会自己回收这些内存，同时调用元素的析构函数�?/font>
但是如果你把指针攑ֈ�容器中，clear的时候容器只负责回收指针本��n所占的内存�Q�至于指针所指向的东西，它是不管�?/font>

肥仔 2009-09-02 22:23 发表评论

肥仔 — Mon, 31 Aug 2009 15:08:00 GMT

一. �U�类�Q?span lang="EN-US">

· 标准STL序列容器�Q?span lang="EN-US">vector�?span lang="EN-US">string�?span lang="EN-US">deque�?span lang="EN-US">list�?

· 标准STL兌��容器�Q?span lang="EN-US">set�?span lang="EN-US">multiset�?span lang="EN-US">map�?span lang="EN-US">multimap�?

· 非标准序列容�?/span>slist�?span lang="EN-US">rope�?span lang="EN-US">slist是一个单向链表，rope本质上是一个重型字�W�串

· 非标准关联容�?/span>hash_set�?span lang="EN-US">hash_multiset�?span lang="EN-US">hash_map�?span lang="EN-US">hash_multimap�?

· 几种标准�?span lang="EN-US">STL容器�Q�包括数�l��?span lang="EN-US">bitset�?span lang="EN-US">valarray�?span lang="EN-US">stack�?span lang="EN-US">queue�?span lang="EN-US">priority_queue

值得注意的是�Q�数�l�可以和STL��法配合�Q�因为指针可以当作数�l�的�q�代器��?/span>�?/span>

�?span lang="EN-US">.删除元素

如果惛_��除东西，��C��remove��法后，要加�?span lang="EN-US">erase

所谓删除算法，最�l�还是要调用成员函数��d��除某个元素，但是因�ؓremove�q�不知道它现在作用于哪个容器�Q�所�?span lang="EN-US">remove��法不可能真的删除一个元�?span lang="EN-US">

1.Vector

vector 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�Q?span lang="EN-US">

2. list

list listTest;

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

remove�?span lang="EN-US">remove_if之间的十分相伹{��但unique行�ؓ也像remove。它用来从一个区间删除东西（邻近的重复��|��而不用访问持有区间元素的容器。如果你真的要从容器中删除元素，你也必须成对调用unique�?span lang="EN-US">erase�Q?span lang="EN-US">unique�?span lang="EN-US">list中也�c�M��?span lang="EN-US">remove。正�?span lang="EN-US">list::remove真的删除东西�Q�而且�?span lang="EN-US">erase-remove惯用法高效得多）�?span lang="EN-US">list::unique也真的删除邻�q�的重复��|��也比erase-unique高效�Q��?span lang="EN-US">

�?�q�代器失效：

一个网友提的问题：

void   main()
{
vector vcs;
vcs.push_back( "this   is   A ");
vector ::iterator   it=vcs.begin();
int   i=9;
for(;it!=vcs.end();++it)
{
cout < < "caplity   of   vector   is   :   " <
cout < < "---> " < <*it < ��L��此句会有一个超�q?span lang="EN-US">vector
                                   //大小的��@环，高手能解释一下�ؓ什�?span lang="EN-US">?
if(i==9)
{
vcs.push_back( "this   is   BBBBB ");
cout < < "vcs.push! " < }
i=8;
}
}

典型的�P代器失效....

vector�Q?span lang="EN-US">
1.当插入（push_back�Q�一个元素后�Q?span lang="EN-US">end操作�q�回的�P代器肯定失效�?span lang="EN-US">
2.当插�?span lang="EN-US">(push_back)一个元素后�Q?span lang="EN-US">capacity�q�回��g��没有插入元素之前相比有改变，则需要重新加载整个容器，此时first�?span lang="EN-US">end操作�q�回的�P代器都会失效�?span lang="EN-US">
3.当进行删除操作（erase�Q?span lang="EN-US">pop_back�Q�后�Q�指向删除点的�P代器全部失效�Q�指向删除点后面的元素的�q�代器也��全部失效�?span lang="EN-US">

deque�q�代器的失效情况�Q?span lang="EN-US">
1.�?span lang="EN-US">deque容器首部或者尾部插入元素不会��得�Q何�P代器失效�?span lang="EN-US">
2.在其首部或尾部删除元素则只会使指向被删除元素的�P代器失效�?span lang="EN-US">
3.�?span lang="EN-US">deque容器的�Q何其他位�|�的插入和删除操作将使指向该容器元素的所有�P代器失效�?span lang="EN-US">

List/set/map

1.删除�Ӟ��指向该删除节点的�q�代器失�?span lang="EN-US">

list intList;
list::iterator it = intList.begin();
while(it != intList.end())
{
it = intList.erase(it);
…�?span lang="EN-US">
}

�?span lang="EN-US">.选择时机<�?span lang="EN-US">>--�ȝ��各种容器特点

(1) vector
内部数据�l�构�Q�数�l��?span lang="EN-US">
随机讉K��每个元素�Q�所需要的旉��为常量�?span lang="EN-US">
在末��֢�加或删除元素所需旉��与元素数目无养I��在中间或开头增加或删除元素所需旉��随元素数目呈�U�性变化�?span lang="EN-US">
可动态增加或减少元素�Q�内存管理自动完成，但程序员可以使用reserve()成员函数来管理内存�?span lang="EN-US">
vector的�P代器在内存重新分配时��失效（它所指向的元素在该操作的前后不再相同�Q�。当把超�q?span lang="EN-US">capacity()-size()个元素插�?span lang="EN-US">vector中时�Q�内存会重新分配�Q�所有的�q�代器都��失效；否则�Q�指向当前元素以后的��M��元素的�P代器都将失效。当删除元素�Ӟ��指向被删除元素以后的��M��元素的�P代器都将失效�?span lang="EN-US">

(2)deque
内部数据�l�构�Q�数�l��?span lang="EN-US">
随机讉K��每个元素�Q�所需要的旉��为常量�?span lang="EN-US">
在开头和末尾增加元素所需旉��与元素数目无养I��在中间增加或删除元素所需旉��随元素数目呈�U�性变化�?span lang="EN-US">
可动态增加或减少元素�Q�内存管理自动完成，不提供用于内存管理的成员函数�?span lang="EN-US">
增加��M��元素都将�?span lang="EN-US">deque的�P代器失效。在deque的中间删除元素将使�P代器失效。在deque的头或尾删除元素�Ӟ��只有指向该元素的�q�代器失效�?span lang="EN-US">

(3)list
内部数据�l�构�Q�双向环犉��表�?span lang="EN-US">
不能随机讉K��一个元素�?span lang="EN-US">
可双向遍历�?span lang="EN-US">
在开头、末��֒�中间��M��地方增加或删除元素所需旉��都�ؓ帔R��?span lang="EN-US">
可动态增加或减少元素�Q�内存管理自动完成�?span lang="EN-US">
增加��M��元素都不会�ɘq�代器失效。删除元素时�Q�除了指向当前被删除元素的�P代器外，其它�q�代器都不会失效�?span lang="EN-US">

(4)slist
内部数据�l�构�Q�单向链表�?span lang="EN-US">
不可双向遍历�Q�只能从前到后地遍历�?span lang="EN-US">
其它的特性同list�怼��?span lang="EN-US">

(5)stack
适配器，它可以将��L��c�d��的序列容器�{换�ؓ一个堆栈，一般��?span lang="EN-US">deque作�ؓ支持的序列容器�?span lang="EN-US">
元素只能后进先出�Q?span lang="EN-US">LIFO�Q��?span lang="EN-US">
不能遍历整个stack�?span lang="EN-US">

(6)queue
适配器，它可以将��L��c�d��的序列容器�{换�ؓ一个队列，一般��?span lang="EN-US">deque作�ؓ支持的序列容器�?span lang="EN-US">
元素只能先进先出�Q?span lang="EN-US">FIFO�Q��?span lang="EN-US">
不能遍历整个queue�?span lang="EN-US">

(7)priority_queue
适配器，它可以将��L��c�d��的序列容器�{换�ؓ一个优先��队列�Q�一般��?span lang="EN-US">vector作�ؓ底层存储方式�?span lang="EN-US">
只能讉K��W�一个元素，不能遍历整个priority_queue�?span lang="EN-US">
�W�一个元素始�l�是优先�U�最高的一个元素�?span lang="EN-US">

(8)set
键和值相�{��?span lang="EN-US">
键唯一�?span lang="EN-US">
元素默认按升序排列�?span lang="EN-US">
如果�q�代器所指向的元素被删除�Q�则该�P代器失效。其它�Q何增加、删除元素的操作都不会�ɘq�代器失效�?span lang="EN-US">

(9)multiset
键可以不唯一�?span lang="EN-US">
其它特点�?span lang="EN-US">set相同�?span lang="EN-US">

(10)hash_set
�?span lang="EN-US">set相比较，它里面的元素不一定是�l�过排序的，而是按照所用的hash函数分派的，它能提供更快的搜索速度�Q�当然跟hash函数有关�Q��?span lang="EN-US">
其它特点�?span lang="EN-US">set相同�?span lang="EN-US">

(11)hash_multiset
键可以不唯一�?span lang="EN-US">
其它特点�?span lang="EN-US">hash_set相同�?span lang="EN-US">

(12)map
键唯一�?span lang="EN-US">
元素默认按键的升序排列�?span lang="EN-US">
如果�q�代器所指向的元素被删除�Q�则该�P代器失效。其它�Q何增加、删除元素的操作都不会�ɘq�代器失效�?span lang="EN-US">

(13)multimap
键可以不唯一�?span lang="EN-US">
其它特点�?span lang="EN-US">map相同�?span lang="EN-US">

(14)hash_map
�?span lang="EN-US">map相比较，它里面的元素不一定是按键值排序的�Q�而是按照所用的hash函数分派的，它能提供更快的搜索速度�Q�当然也�?span lang="EN-US">hash函数有关�Q��?span lang="EN-US">
其它特点�?span lang="EN-US">map相同�?span lang="EN-US">

(15)hash_multimap
键可以不唯一�?span lang="EN-US">
其它特点�?span lang="EN-US">hash_map相同�?span lang="EN-US">

肥仔 2009-08-31 23:08 发表评论

STLPORT的bug

肥仔 — Thu, 16 Jul 2009 08:52:00 GMT

当采用静态连接，定义�?,_STLP_USE_STATIC_LIB

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

template
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);
}

解决办法�Q?/p>

使用动态库的STLPORT

肥仔 2009-07-16 16:52 发表评论

肥仔 — Thu, 09 Jul 2009 06:48:00 GMT

先看两条规制�Q?span lang="EN-US">

1�Q�对于节点式容器(map, list, set)元素的删除，插入操作会导致指向该元素的�P代器失效�Q�其他元素�P代器不受影响

2�Q�对于顺序式容器(vector)元素的删除、插入操作会��D��指向该元素以及后面的元素的�P代器失效

常见的错误代码示例：

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 sMemList;
3typedef vector::iterator sIT;
4sMemList MemList;

1    // �q�代器失�?span lang="EN-US">
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    }

两种解决�Ҏ(gu��)��Q?span lang="EN-US">
对于��序容器�Q?

bool Equal10(sMem* pMem)
{

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

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

对于�l�点容器�Q?span lang="EN-US">

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    }

肥仔 2009-07-09 14:48 发表评论

stlport的link error

肥仔 — Mon, 18 May 2009 06:32:00 GMT

一下几个步骤组合会引发�q�个问题
1、在stdafx.h中定义了“_STLP_USE_STATIC_LIB”�Q��用静态库�q�接�Q?br>2、但是的有cpp文�g使用了STLPort�Q�但是设�|��ؓ不��用头文�g�Q�也��是没有#include"stdafx.h"�Q?br>
解决办法�Q?br>�?#8220;_STLP_USE_STATIC_LIB”的定义放�?Project Settings里面�?/p>

肥仔 2009-05-18 14:32 发表评论

肥仔 — Sat, 08 Nov 2008 17:14:00 GMT


名称		功能描述
equal_to		相等
not_equal_to		不相�{?/span>
less		��于
greater		大于
less_equal		��于�{�于
greater_equal		大于�{�于

实例�Q?span lang="EN-US">
//less()默认排序�Q�－升序
//greater()
vector < int > vect;
//...
sort(vect.begin(), vect.end());
//此时相当于调�?/span>
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

肥仔 2008-11-09 01:14 发表评论

std::find用法错误记录

肥仔 — Thu, 06 Nov 2008 07:33:00 GMT

//---- std::find�q�回的是扑ֈ�的�P代器位置�Q�如果没有找刎ͼ�会返回last iter�Q�其他算法类�?/p>

int data[32] = {0};

int* pFind = NULL;

if(pFind = std::find_if(data, data + sizeof(data)/sizeof(int), cmp_fun))//---判断扑ֈ��?/p>

//---- 正确的是

if((data + sizeof(data)/sizeof(int)) != (pFind = std::find_if(data, data + sizeof(data)/sizeof(int), cmp_fun)))//---判断扑ֈ��?/p>

肥仔 2008-11-06 15:33 发表评论

STLPort 的预定义

肥仔 — Mon, 20 Oct 2008 02:16:00 GMT

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

#define _STLP_USE_STATIC_LIB

攑ֈ�ALT+F7->C++->Preprocessor definitions里面卛_��Q�DEBUG和RELEASE都改�Q?/p>

肥仔 2008-10-20 10:16 发表评论

肥仔 — Sat, 18 Oct 2008 16:38:00 GMT

输出档案(archive)�c�M��于输出数据流(stream)。数据能通过<< �?& 操作�W�存储到档案(archive)�?

ar << data;

ar & data;

输入档案(archive)�c�M��于输入数据流(stream)。数据能通过>> �?& 操作�W�从档案(archive)中装载�?

ar >> data;

ar & data;

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

一个非常简单的情�Ş

通常用serialize 函数来存储和装蝲�cȝ��数据成员�?

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

#include

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

#include

#include

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

// 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

    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;

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

非��R入的版本

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

#include

#include

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

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

    ar & g.degrees;

    ar & g.minutes;

    ar & g.seconds;

} // namespace serialization

} // namespace boost

�q�种情况生成的serialize 函数不是gps_position�cȝ��成员函数。这有异曲同工之妙�?

非��R入序列化主要应用在不改变�c�d��义就可实现类的序列化。�ؓ实现�q�种可能�Q�类必须提供��_��的信息来更新�cȝ��态。在�q�个例子中，我们假设�c�L��public成员。仅当提供��够信息来存储和装载的�c�，才能不改变类自��n�Q�在外部来序列化�cȝ��态�?

可序列化的成�?/a>

一个可序列化的�c�，可拥有可序列化的成员�Q�例如：

class bus_stop

    friend class boost::serialization::access;

    template

    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(){}

};

�q�里�Q�类�c�d��的成员被序列化，恰如原始�c�d��被序列化一栗��?

注意�Q�类bus_stop的实例“存储”时�Q�其归档(archive)操作�W�将调用latitude �?longitude的serialize 函数。这��依�ơ调用定义在gps_position中的serialize 来被“存储”。这�U�手法中�Q�通过bus_stop的归�?archive)操作�W?整个数据�l�构被存�?bus_stop是它的根条目�?

�z��c?/a>

�z��c�d��包含其基�cȝ��序列化�?

#include

class bus_stop_corner : public bus_stop

    friend class boost::serialization::access;

    template

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

        // serialize base class information

        ar & boost::serialization::base_object(*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_)

{}

};

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

指针

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

我们可以有几�U�bus stop的类型（��C��bus_stop是一个基�c�）�?
一个所�l�的 bus_stop可以展现多于一个的路线�?

一个bus route 用一�l�指向bus_stop的指针来描述是方便的�?pre>

class bus_route

    friend class boost::serialization::access;

    bus_stop * stops[10];

    template

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

        int i;

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

            ar & stops[i];

public:

    bus_route(){}

};

数组stops 的每个成员将被序列化。但是，��C��每个成员是个指针�?- 实际含义是什么？序列化整个对象是要求在另一个地方和旉��重新构造原始数据结构。用指针��Z��完成�q�些�Q�存储指针的值是不够的，指针指向的对象必��d��储。当成员最后被装蝲�Q�一个新的对象被创徏�Q�新的指针被装蝲到类的成员中�?

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

数组

事实上上�q�方案比较复杂。序列化库能��出被序列化的对象是一个数�l�，��生上�q�等��L��代码。因此上�q�C��码能更短的写为：

class bus_route

    friend class boost::serialization::access;

    bus_stop * stops[10];

    template

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

        ar & stops;

public:

    bus_route(){}

};

STL容器

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

#include

class bus_route

    friend class boost::serialization::access;

    std::list stops;

    template

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

        ar & stops;

public:

    bus_route(){}

};

�cȝ��版本

假设我们对bus_route�c�L��意，在��品中使用它。一�D�|��间后�Q�发觉bus_route �c�需要包含线路驾驶员的名字。因此新版本如下�Q?

#include

#include

class bus_route

    friend class boost::serialization::access;

    std::list stops;

    std::string driver_name;

    template

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

        ar & driver_name;

        ar & stops;

public:

    bus_route(){}

};

好，完毕�Q�异�?..会发生在��d��旧版本所生成的数据文件时。如何考虑版本问题�Q?

通常�Q�序列化库�ؓ每个被序列化的类在档案中存储版本受��缺省值是0。当档案装蝲�Ӟ��存储的版本号可被��d��。上�q�C��码可修改如下�Q?pre>

#include

#include

#include

class bus_route

    friend class boost::serialization::access;

    std::list stops;

    std::string driver_name;

    template

    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)

�Ҏ(gu��)��个类通过应用的版本，没有必要�l�护一个版本文件。一个文件版本是所有它�l�成的类的版本的联合。系�l�允许程序和以前版本的程序创建的档案向下兼容�?

把serialize拆分成save/load

serialize函数是简单，��z�，�q�且保证�c�L��员按同样的顺序（序列化系�l�的key�Q�被存储/被装载。可是有像这里例子一��P��装蝲和存储不一致的情�Ş。例如，一个类有多个版本的情况发生。上�q�情形能重写为：

#include

#include

#include

#include

class bus_route

    friend class boost::serialization::access;

    std::list stops;

    std::string driver_name;

    template

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

        // note, version is always the latest when saving

        ar  & driver_name;

        ar  & stops;

    template

    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的代码，依赖于是否档案被用于“存储”或“装载”�?

档案

我们�q�里讨论��聚焦到�cȝ��序列化能力上。被序列化的数据的实际编码实��C��档案(archive)�c�M��。被序列化的数据��是所选档�?archive)�cȝ��序列化的产物�?�?key设计军_��q�两个组件的独立性。允�怓Q何序列化的规范可用于��M��档案(archive)�?

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

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

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

T完整的演�C�程�?- demo.cpp 包括�Q?

创徏各种�c�d��?stops, routes �?schedules
昄��?
序列化到一个名�?"testfile.txt"的文件中
�q�原到另一个结构中
昄��被存储的�l�构

�q�个�E�序的输�?/a> 分证实了对序列化�pȝ��所有的要求�Q�都在这个系�l�中体现了。对序列化文件是ASCII文本�?a >档案文�g的内�?/a> 能被昄��?/p>

肥仔 2008-10-19 00:38 发表评论

肥仔 — Thu, 16 Oct 2008 05:28:00 GMT

借助valgrind�Q�终于找��C��个隐藏很久的bug�Q?br>

class A
{

};
std::vector<A> vecArray;

vecArray.push_back( );
vecArray.push_back( );
vecArray.push_back( );

A & a= vecArray.back();
vecArray.push_back( );

以上的代码骤眼看上去也没有什么奇怪的地方�Q�经�q�多�ơ的��试也没有发��C��么问题。但昨天bug�l�于爆发了，�E�序��L��无缘无故down掉�?br>其实原因很简单，��是�?A & a = vecArray.back(); �q�一步�?br>vector是一个会自增长的容器�Q�自增长的结果就是把原来的内存释放掉�Q�重新分配一个��够大的内存。既然原来的内存已经释放掉，那么a所引用的内存就是一�D�|��效的内存。对无效内存的访问，后果有多严重��׃��用多说了�?br>
惌��x��法也很多�Q�最��单就是用std::list或者std::deque替代vector�?

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

Comments

# re: 使用std::vector的一个误�?
glacjay
Posted @ 2005-11-09 22:06
不可以保存烦引吗�Q�必��要用指针吗�Q��ؓ了效率？回复更多评论
# re: 使用std::vector的一个误�?
cyt
Posted @ 2005-11-10 09:23
用烦引是可以�Q�不�q�个��Z��大喜�Ƣ用索引。其原因��是索引�q�不是stl容器所共有的特性，一旦��用了索引�Q�以后如果需要�{换�ؓ其他容器的时候，未免需要改动不��地斏V��另外，我这里所说的只是一�U�解��x��法。对于我�q�种情况�Q�只需要更改一个typedef定义��可以解决问题。如果改成是用烦引的话，需要更改不��地方，而且很容易会漏了�?
�E�序本��n��法也比较复杂，相对来说使用索引性能也不会下降多��，�q�个倒不是什么需要考虑的地方了�?nbsp; 回复更多评论
# re: 使用std::vector的一个误�?
nilaozi
Posted @ 2005-11-11 22:23
最后一�ơ评论。也够出气了�Q?
一个在blogjava失去家园的�h声讨�?
除了政治原因可以删了一个�hblog�Q�别的理由都不能成�ؓ理由�?
我�ؓ每个都到他们所需的ebook��N��错了�Q?
贴到首页�Q�我�q�以你们有预��x��Ӟ��CSDN是这��P��理员认为可以才攑ֈ�首页�?
不信你到他们的首��늜�看�?
http://csdn.blog.net/ahhoo
如果你认��不错的，请到回脓(chu��ng)�?
回复更多评论
# re: 使用std::vector的一个误�?
blues
Posted @ 2006-09-04 14:05
vector和deque的差别是操作上的�Q�list虽然是基于链表的�Q�但是不能随��问，��M��的容器都不是完美的，而且使用指针必然要判断，但也��是个bug�Q?
我想解决的话�c�d��用boost的any应该可以了，它本�w�带有安全检查，我没试仅是徏�?nbsp; 回复更多评论
# re: 使用std::vector的一个误�?a name="Post">
stl
Posted @ 2008-10-06 01:03
STL里的容器大部分都是“值”容器，你用“引用”去讉K��容器里的内容�Q�错了正常。这不是vector的问题，你自�׃��用的问题。如果基于性能考虑上面的程序一定要使用“引用”语意的话，应该用vector的写法才比较正确�?nbsp; 回复更多评论

肥仔 2008-10-16 13:28 发表评论

iterator�Ҏ(gu��)��值加减的分别

肥仔 — Mon, 13 Oct 2008 03:25:00 GMT

//----下面的可�?

vector::iterator iter;
iter = iter + 3;

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

list::iterator iter;
iter = iter + 3;

肥仔 2008-10-13 11:25 发表评论

肥仔 — Tue, 09 Sep 2008 07:53:00 GMT

�I�容器对首元素求地址�q�算

int main(int argc, char* argv[])
{
    vector vec_test;
    list    lst_test;
    set    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�I�地址��试�Q�红色部分无法理�?

int main(int argc, char* argv[])
{
    vector 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;
}

肥仔 2008-09-09 15:53 发表评论

容器.size()�q�回size_t�Q�的注意事项

肥仔 — Tue, 09 Sep 2008 07:26:00 GMT

下面代码的原意是便利vector的前n-1个，但是�Q�没注意到size_t是unsigned int�Q�因此会出现bug.

如果m_vecSymbolSummary.size() == 0,那么m_vecSymbolSummary.size() - 1��会变成很大敎ͼ�而��生问�?/p>

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

肥仔 2008-09-09 15:26 发表评论

容器相等�Q�可�q�行直接判断

肥仔 — Sat, 06 Sep 2008 08:37:00 GMT

vector, list, set, map ,hash_map, hash_set

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

肥仔 2008-09-06 16:37 发表评论

std::sort多关键字排序

肥仔 — Sat, 06 Sep 2008 07:39:00 GMT

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

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 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<    return 0;
}

肥仔 2008-09-06 15:39 发表评论

条款9�Q�在删除选项中仔�l�选择

肥仔 — Sat, 02 Aug 2008 08:57:00 GMT

假定你有一个标准STL容器�Q�c�Q�容�U�int�Q?pre>Container c;

而你��x��c中所有��gؓ1963的对象都��L��。��o人吃惊的是，完成�q�项��d��的方法因不同的容器类型而不同：没有一�U�方法是通用的�?

如果你有一个连�l�内存容器（vector、deque或string——参�?a >条款1�Q�，最好的�Ҏ(gu��)��是erase-remove惯用法（参见条款32�Q�：

c.erase(remove(c.begin(), c.end(), 1963),	// 当c是vector、string
		c.end());			// 或deque�Ӟ��
						// erase-remove惯用�?
						// 是去除特定值的元素
						// 的最��x���?

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

c.remove(1963);		// 当c是list�Ӟ��
			// remove成员函数是去�?
			// 特定值的元素的最��x���?

当c是标准关联容器（卻I��set、multiset、map或multimap�Q�时�Q��用�Q何叫做remove的东襉K��是完全错误的。这��L��容器没有叫做remove的成员函敎ͼ�而且使用remove��法可能覆盖容器��|��参见条款32�Q�，潜在地破坏容器。（关于�q�样的破坏的�l�节�Q�参�?a >条款22�Q�那个条�ƾ也解释了�ؓ什么试囑֜�map和multimap上��用remove肯定不能�~�译�Q�而试囑֜�set和multiset上��用可能不能编译。）

不，对于兌��容器�Q�解决问题的适当�Ҏ(gu��)��是调用erase�Q?pre>c.erase(1963); // 当c是标准关联容器时 // erase成员函数是去�? // 特定值的元素的最��x��?

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

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

bool badValue(int x);	// �q�回x是否是“bad�?/pre>
对于序列容器�Q�vector、string、deque和list�Q�，我们要做的只是把每个remove替换为remove_if�Q�然后就完成了：
c.erase(remove_if(c.begin(), c.end(), badValue),	// 当c是vector、string
			c.end());			// 或deque时这是去�?
						// badValue�q�回�?
						// 的对象的最��x���?
c.remove_if(badValue);				// 当c是list时这是去�?
						// badValue�q�回�?
						// 的对象的最��x���?

对于标准兌���容器�Q�它不是很直截了当。有两种�Ҏ(gu��)��处理该问题，一个更�Ҏ(gu��)���~�码�Q�另一个更高效。“更�Ҏ(gu��)��但效率较低”的解决�Ҏ(gu��)��用remove_copy_if把我们需要的值拷贝到一个新容器中，然后把原容器的内容和新的交换�Q?pre>AssocContainer c;				// c现在是一�U?
...						// 标准兌���容器
AssocContainer goodValues;			// 用于容纳不删�?
						// 的值的临时容器
remove_copy_if(c.begin(), c.end(),			// 从c拯���不删�?
		inserter(goodValues,		// 的值到
			goodValues.end()),		// goodValues
			badValue);
c.swap(goodValues);				// 交换c和goodValues
						// 的内�?

对这�U�方法的�~�点是它拯��了所有不删除的元素，而这��L��拯��开销可能大于我们感兴��支付的�?

我们可以通过直接从原容器删除元素来避开那笔帐单。不�q�，因�ؓ兌��容器没有提供�c�M��remove_if的成员函敎ͼ�所以我们必��d��一个��@环来�q�代c中的元素�Q�和原来一样删除元素�?

看�v来，�q�个��d��很简单，而且实际上，代码也很��单。不�q�的是，那些正确工作的代码很��是跃出脑�v的代码。例如，�q�是很多�E�序员首先想到的�Q?pre>AssocContainer c; ... for (AssocContainer::iterator i = c.begin(); // 清晰�Q�直截了�? i!= c.end(); // 而漏�z�百出的用于 ++i) { // 删除c中badValue�q�回�? if (badValue(*i)) c.erase(i); // 的每个元素的代码 } // 不要�q�么做！

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

��Z��避免�q�个问题�Q�我们必��M��证在调用erase之前��得��C��c中下一元素的�P代器。最�Ҏ(gu��)��的方法是当我们调用时在i上��用后�|�递增�Q?pre>AssocContainer c; ... for (AssocContainer::iterator i = c.begin(); // for循环的第三部�? i != c.end(); // 是空的；i现在在下�? /*nothing*/ ){ // 自增 if (badValue(*i)) c.erase(i++); // 对于坏的��|��把当前的 else ++i; // i传给erase�Q�然�? } // 作�ؓ副作用增加i�Q? // 对于好的��|�� // 只增加i

�q�种调用erase的解��x��法可以工作，因�ؓ表达式i++的值是i的旧��|��但作为副作用�Q�i增加了。因此，我们把i的旧��|��没增加的�Q�传�l�erase�Q�但在erase开始执行前i已经自增了。那正好是我们想要的。正如我所说的�Q�代码很��单，只不�q�不是大多数�E�序员在�W�一�ơ尝试时惛_��的�?

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

对于兌��容器�Q�这说多�Ҏ(gu��)��有多容易，因�ؓ只需要对我们刚才开发的循环做一个微不��道的修改��p��了：

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

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

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

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

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

��Z��避免你奇怪list的适当�Ҏ(gu��)��是什么，事实表明对于�q�代和删除，你可以像vector/string/deque一��h��像关联容器一样对待list�Q�两�U�方法都可以为list工作�?

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

去除一个容器中有特定值的所有对象：
如果容器是vector、string或deque�Q��用erase-remove惯用法�?
如果容器是list�Q��用list::remove�?
如果容器是标准关联容器，使用它的erase成员函数�?/p>
去除一个容器中满��一个特定判定式的所有对象：
如果容器是vector、string或deque�Q��用erase-remove_if惯用法�?
如果容器是list�Q��用list::remove_if�?
如果容器是标准关联容器，使用remove_copy_if和swap�Q�或写一个��@环来遍历容器元素�Q�当你把�q�代器传�l�erase时记得后�|�递增它�?/p>
在��@环内做某些事情（除了删除对象之外�Q�：
如果容器是标准序列容器，写一个��@环来遍历容器元素�Q�每当调用erase时记得都用它的返回值更��C��的�P代器�?
如果容器是标准关联容器，写一个��@环来遍历容器元素�Q�当你把�q�代器传�l�erase时记得后�|�递增它�?/p>

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

肥仔 2008-08-02 16:57 发表评论

STL 查找��法

肥仔 — Fri, 04 Jul 2008 05:36:00 GMT

要给出所有我们在本条�ƾ中所考虑到的�Q�我们的从哪儿着手？下面的表格道��Z��一切�?/p>

你想知道�?	使用的算�?		使用的成员函�?/tr>
你想知道�?	在无序区�?/td>	在已序区�?/td>	在set或map�?/td>	在multiset或multimap�?/td>
期望值是否存在？	find	binary_search	count	find
期望值是否存在？如果有，�W�一个等于这个值的对象在哪里？	find	equal_range	find	find or lower_bound(see article)
�W�一个不�{�于期望值的对象在哪里？	find_if	lower_bound	lower_bound	lower_bound
�W�一个等于期望值的对象在哪里？	find_if	upper_bound	upper_bound	upper_bound
有多��对象等于期望��\|��	count	equal_range	count	count
�{�于期望值的所有对象在哪里�Q?/td>	find�Q��P代）	equal_range	equal_range	equal_range

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

Example

// equal_range example
#include 
#include 
#include 
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 v(myints,myints+8);                         // 10 20 30 30 20 10 10 20
  pair::iterator,vector::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 );

//�q�回pair �Q�若容器中存在搜索��|���W�一个返回by lower_bound(); �W�二�?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
#include
#include
#include
#include
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() );
      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() );
      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() );
      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
           ;
}

肥仔 2008-07-04 13:36 发表评论

EffectiveSTL�Q�Item16�Q�如何将vector和string的数据传�l�传�l�的API函数

肥仔 — Thu, 19 Jun 2008 08:13:00 GMT

Item 16�Q�如何将vector和string的数据传�l�传�l�的API函数

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

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

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

�l�定一�?

vector v;

表达式v[0]生��一个指向vector中首元素的引用，所以，&v[0]是指向那个首元素的指针。vector中的元素被C++标准限定为存储在�q�箋内存中，��p��是一个数�l�，所以，如果我们传递v�l�如此�Ş式的C风格API函数

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

我们可以�q�么做：

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

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

if (!v.empty()) {

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

}

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

�c�M��的从vector上获取指向内部数据的指针的方法，对string是不可靠的，因�ؓ

(1) string中的数据�q�没有承��存储在连�l�内存中�Q?

(2)string的内部表�C��Ş式�ƈ没承��Z��一个空字符�l�束�?

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

void doSomething(const char *pString);

��p��q�样�Q?

doSomething(s.c_str());

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

再看一下doSomething()的申明：

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

void doSomething(const char *pString);

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

对于vector�Q�有更多一点点灉|��性。如果你��v传给一个修改其元素的C风格API函数的话�Q�典型情况都是没问题�Q�但被调用的函数�l�不能试图改变vector中元素的个数。比如，它绝不能试图在vector�q�未使用的容量（capacity�Q�上“创建”新的元素。如果这么干了，v��会变得内部状态不一��_��因�ؓ它再也不知道自己的正��大��（size�Q�了。v.size()��会得到一个不正确的结果。�ƈ且，如果被调用的函数试图在一个大��和定w��Q�见Item 14�Q�相�{�的vector上追加数据的话，真的会发生灾难性事件。我甚至�Ҏ(gu��)��׃��愿去惌��它。实在太可怕了�?

你注意到我在前面用的是“典型地”一词吗�Q�你当然注意��C��。有些vector对其数据有些额外的限�Ӟ��你一定要��保�q�些额外限制�l�箋被满��뀂�D个例子，Item 23解释了排序的vector常用来实现关联容器，但对�q�些vector而言�Q�保持排序非帔R��要。如果你��一个排序的vector传给一个可能修改其数据的API函数�Q�你需要重视vector在调用返回后不再保持排序的情��c�?

如果你想用C风格API函数�q�回的元素初始化一个vector�Q�你可以利用vector和数�l�内在的相容性，通过��存储vecotr的元素的�I�间传给API函数�Q?

// 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 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

�q�个技巧只能工作于vector�Q�因为只有vector承诺了与数组��h��相同的内在内存分布。但是，如果你想用来自C风格API函数的数据初始化string对象�Q�你可以做得��_��单。只要让API函数��数据放入一个vector�Q�然后从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 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)

事实上，�q�个��L��L��有效的：让C风格API函数��数据放入一个vector�Q�然后拷��C��实际惌��的STL容器中�?

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

vector vd(maxNumDoubles); // also as above

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

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

// deque

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

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

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

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

set intSet; // set that will hold

... // data to pass to API

vector 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

你也可以��数据拷�q�一个数�l�，然后��数�l�传�l�C风格的API�Q�但你�ؓ什么想�q�样做？除非你在�~�译期就知道容器的大��，否则你不得不分配动态数�l�，而Item 13解释了�ؓ什么你应该��L��使用vector来取代动态分配的数组�?

肥仔 2008-06-19 16:13 发表评论

肥仔 — Fri, 16 May 2008 16:16:00 GMT

　从传�l�意义上来说�Q�boost.spirit库是一个类��g��yacc的库�Q�主要业务是做词法解析，然后提供各种��d��数据的接口，但是�׃��q�是一个用C++实现、�ƈ且大量运Expression Templates技巧的�?..

点击下蝲此文�Ӟ�� 单的四则计算器源码和可执行程�?/a>

从传�l�意义上来说�Q�boost.spirit库是一个类��g��yacc的库�Q�主要业务是做词法解析，然后提供各种��d��数据的接口，但是�׃��q�是一个用C++实现、�ƈ且大量运 Expression Templates技巧的库，所以各�U�功能可以用非常快捷的方式实玎ͼ�非常的好用，几乎把C++的各�U�优良特性都充分发挥出来�?br>
在此�Q�我��׃��boost.spirit库中间的一个例子出发，�l�过��单的修改��变成一个极为健壮的四则计算器。我所参考的例子是boost 1.34.0的libs/spirit/example/fundamental/calc_plain.cpp�Q�我因�ؓ是在�q�上面直接修改而来�Q�所以源码中带有原作者的版权声明�?br>
关于boost.spirit的用法，在这里我先不��_��以后有时间我来慢慢的把它用中国话讲解一遍。这个程序的核心实际上是一个EBNF的表辑ּ��Q�也��是如何用EBNF语法来表�C�四则运��?br>在这里，我就直接�l�出�{�案�Q�EBNF的知识请暂时自行看编译原理的教材�Q�：

�E�序代码

其中�Q�expression��是我们需要的表达式pattern。注意这里，正是�׃��expression首先��d��配term�Q�而term首先��d��配factor�Q�最后factor是以“纯数字”、“括号”、“正负符号”的��序匚w��Q�term则是以factor、“乘法”、“除法”的��序匚w��Q�而expression是以term、“加法”、“减法”的��序匚w��Q�所以就保证了整个表辑ּ�匚w��q�程是按照四则运��的先后��序�q�行的。在匚w��的过�E�中只要安插各种“监视”的函数�Q�boost.spirit里面的术语叫做“actor”）�Q�就可以��L��实现四则�q�算�?br>
把EBNF对应到boost.spirit里，具体的grammer�c�d��现如下：

�E�序代码

struct calculator : public grammar
{
    template
    struct definition
    {
        definition(calculator const& /*self*/)
        {
            expression
                =   term
                >> *(   ('+' >> term[do_calc()])
            |   ('-' >> term[do_calc()])
            )
                ;

            term
                =   factor
                >> *(   ('*' >> factor[do_calc()])
            |   ('/' >> factor[do_calc()])
            )
                ;

            factor
                =   real_p[&push_real]
            |   '(' >> expression >> ')'
                |   ('-' >> factor[&do_neg])
            |   ('+' >> factor)
                ;
        }

        rule expression, term, factor;

        rule const&
            start() const { return expression; }
    };
};

��h��意，calculator从grammer�z��Q�但是除了在内部定义了一个嵌套class以外�Q��ƈ没有做更多的事情�?br>
至于�q�里面用到的do_calc<>、push_real�{�functor和函敎ͼ�则是一些极为简单的东西�Q�实现如下：

�E�序代码

namespace
{
    stack calc_stack;

    struct do_add
    {
        double operator () (double lhs, double rhs) const
        {
            return lhs + rhs;
        }
    };

    struct do_substract
    {
        double operator () (double lhs, double rhs) const
        {
            return lhs - rhs;
        }
    };

    struct do_multiply
    {
        double operator () (double lhs, double rhs) const
        {
            return lhs * rhs;
        }
    };

    struct do_divide
    {
        double operator () (double lhs, double rhs) const
        {
            return lhs / rhs;
        }
    };

    template
    struct do_calc
    {
        void operator () (const char *, const char *) const
        {
            double result = calc_stack.top();
            calc_stack.pop();
            result = op()(calc_stack.top(), result);
            calc_stack.pop();
            calc_stack.push(result);
        }
    };

    void push_real(double d)
    {
        calc_stack.push(d);
    }

    void do_neg(char const*, char const*)
    {
        cout << "NEGATE\n";
        double result = calc_stack.top();
        calc_stack.pop();
        calc_stack.push(-result);
    }

    double show_result()
    {
        return calc_stack.top();
    }
}

可以从源码中清晰看到�Q�这些函数就是简单的做了些出�?入栈以及�q�算的工作，每一个函数功能极为单�U�，可认为就是一些状态及处理函数而已�Q�而状态机逻辑则由grammer搞定了�?

原文链接�Q?a >http://www.realdodo.com/blog/article.asp?id=216

肥仔 2008-05-17 00:16 发表评论

肥仔 — Sat, 10 May 2008 14:25:00 GMT

"^\d+$"　　//非负整数�Q�正整数 + 0�Q?
"^[0-9]*[1-9][0-9]*$"　　//正整�?
"^((-\d+)|(0+))$"　　//非正整数�Q�负整数 + 0�Q?
"^-[0-9]*[1-9][0-9]*$"　　//负整�?
"^-?\d+$"　　　　//整数
"^\d+(\.\d+)?$"　　//非负��点敎ͼ�正��Q�Ҏ(gu��)�� + 0�Q?
"^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$"　　//正��Q�Ҏ(gu��)��
"^((-\d+(\.\d+)?)|(0+(\.0+)?))$"　　//非正��点敎ͼ�负��Q�Ҏ(gu��)�� + 0�Q?
"^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$"　　//负��Q�Ҏ(gu��)��
"^(-?\d+)(\.\d+)?$"　　//��点�?
"^[A-Za-z]+$"　　//�?6个英文字母组成的字符�?
"^[A-Z]+$"　　//�?6个英文字母的大写�l�成的字�W�串
"^[a-z]+$"　　//�?6个英文字母的��写�l�成的字�W�串
"^[A-Za-z0-9]+$"　　//由数字和26个英文字母组成的字符�?
"^\w+$"　　//由数字�?6个英文字母或者下划线�l�成的字�W�串
"^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$"　　　　//email地址
"^[a-zA-z]+://(\w+(-\w+)*)(\.(\w+(-\w+)*))*(\?\S*)?$"　　//url
/^(d{2}|d{4})-((0([1-9]{1}))|(1[1|2]))-(([0-2]([1-9]{1}))|(3[0|1]))$/   // �q?�?�?/span>
/^((0([1-9]{1}))|(1[1|2]))/(([0-2]([1-9]{1}))|(3[0|1]))/(d{2}|d{4})$/   // �?�?�q?/span>
"^([w-.]+)@(([[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.)|(([w-]+.)+))([a-zA-Z]{2,4}|[0-9]{1,3})(]?)$"   //Emil
"(d+-)?(d{4}-?d{7}|d{3}-?d{8}|^d{7,8})(-d+)?"     //电话��L��
"^(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5]).(d{1,2}|1dd|2[0-4]d|25[0-5])$"   //IP地址

匚w��中文字符的正则表辑ּ��Q?[\u4e00-\u9fa5]
匚w��双字节字�W?包括汉字在内)�Q�[^\x00-\xff]
匚w��I��的正则表辑ּ��Q�\n[\s| ]*\r
匚w��HTML标记的正则表辑ּ��Q?<(.*)>.*<\/\1>|<(.*) \/>/
匚w��首尾�I�格的正则表辑ּ��Q?^\s*)|(\s*$)
匚w��Email地址的正则表辑ּ��Q�\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*
匚w��|�址URL的正则表辑ּ��Q�^[a-zA-z]+://(\\w+(-\\w+)*)(\\.(\\w+(-\\w+)*))*(\\?\\S*)?$
匚w��帐号是否合法(字母开��_��允许5-16字节�Q�允许字母数字下划线)�Q�^[a-zA-Z][a-zA-Z0-9_]{4,15}$
匚w��国内电话��L��Q?\d{3}-|\d{4}-)?(\d{8}|\d{7})?
匚w��腾讯QQ��P��^[1-9]*[1-9][0-9]*$

下表是元字符及其在正则表辑ּ�上下文中的行为的一个完整列表：

\ ��下一个字�W�标��Cؓ一个特�D�字�W�、或一个原义字�W�、或一个后向引用、或一个八�q�制转义�W��?br>
^ 匚w��输入字符串的开始位�|�。如果设�|�了 RegExp 对象的Multiline 属性，^ 也匹�?’\n�?�?’\r�?之后的位�|��?

$ 匚w��输入字符串的�l�束位置。如果设�|�了 RegExp 对象的Multiline 属性，$ 也匹�?’\n�?�?’\r�?之前的位�|��?

* 匚w��前面的子表达式零�ơ或多次�?

+ 匚w��前面的子表达式一�ơ或多次�? �{��h(hu��n)�?{1,}�?

? 匚w��前面的子表达式零�ơ或一�ơ�? �{��h(hu��n)�?{0,1}�?

{n} n 是一个非负整敎ͼ�匚w��定的n �ơ�?br>
{n,} n 是一个非负整敎ͼ�臛_��匚w��n �ơ�?

{n,m} m �?n 均�ؓ非负整数�Q�其中n <= m。最��匹�?n �ơ且最多匹�?m �ơ。在逗号和两个数之间不能有空根{�?br>
? 当该字符紧跟在�Q何一个其他限制符 (*, +, ?, {n}, {n,}, {n,m}) 后面�Ӟ��匚w��模式是非贪婪的。非贪婪模式��可能少的匹配所搜烦的字�W�串�Q�而默认的贪婪模式则尽可能多的匚w��所搜烦的字�W�串�?

. 匚w��?"\n" 之外的�Q何单个字�W�。要匚w��包括 ’\n�?在内的�Q何字�W�，请��用象 ’[.\n]�?的模式�?
(pattern) 匚w��pattern �q�获取这一匚w��?

(?:pattern) 匚w��pattern 但不获取匚w��l�果�Q�也��是说这是一个非获取匚w��Q�不�q�行存储供以后��用�?

(?=pattern) 正向预查�Q�在��M��匚w�� pattern 的字�W�串开始处匚w��查找字符丌Ӏ�这是一个非获取匚w��Q�也��是��_��该匹配不需要获取供以后使用�?

(?!pattern) 负向预查�Q�与(?=pattern)作用相反

x|y 匚w�� x �?y�?

[xyz] 字符集合�?

[^xyz] 负值字�W�集合�?

[a-z] 字符范围�Q�匹配指定范围内的�Q意字�W��?

[^a-z] 负值字�W�范��_��匚w��M��不在指定范围内的��L��字符�?

\b 匚w��一个单词边界，也就是指单词和空格间的位�|��?br>
\B 匚w��非单词边界�?

\cx 匚w��由x指明的控制字�W��?

\d 匚w��一个数字字�W�。等价于 [0-9]�?

\D 匚w��一个非数字字符。等价于 [^0-9]�?

\f 匚w��一个换��늬�。等价于 \x0c �?\cL�?

\n 匚w��一个换行符。等价于 \x0a �?\cJ�?

\r 匚w��一个回车符。等价于 \x0d �?\cM�?

\s 匚w��M��I�白字符�Q�包括空根{��制表符、换��늬��{�等。等价于[ \f\n\r\t\v]�?

\S 匚w��M��非空白字�W�。等价于 [^ \f\n\r\t\v]�?

\t 匚w��一个制表符。等价于 \x09 �?\cI�?

\v 匚w��一个垂直制表符。等价于 \x0b �?\cK�?

\w 匚w��包括下划�U�的��M��单词字符。等价于’[A-Za-z0-9_]’�?

\W 匚w��M��非单词字�W�。等价于 ’[^A-Za-z0-9_]’�?

\xn 匚w�� n�Q�其�?n 为十六进制�{义倹{��十六进制�{义值必��Mؓ��定的两个数字长�?br>
\num 匚w�� num�Q�其中num是一个正整数。对所获取的匹配的引用�?

\n 标识一个八�q�制转义值或一个后向引用。如�?\n 之前臛_�� n 个获取的子表辑ּ��Q�则 n 为后向引用。否则，如果 n 为八�q�制数字 (0-7)�Q�则 n ��Z��个八�q�制转义倹{�?

\nm 标识一个八�q�制转义值或一个后向引用。如�?\nm 之前臛_��有is preceded by at least nm 个获取得子表辑ּ��Q�则 nm 为后向引用。如�?\nm 之前臛_��?n 个获取，�?n ��Z��个后跟文�?m 的后向引用。如果前面的条�g都不满��Q�若 n �?m 均�ؓ八进制数�?(0-7)�Q�则 \nm ��匹配八�q�制转义�?nm�?

\nml 如果 n 为八�q�制数字 (0-3)�Q�且 m �?l 均�ؓ八进制数�?(0-7)�Q�则匚w��八进制�{义�?nml�?

\un 匚w�� n�Q�其�?n 是一个用四个十六�q�制数字表示的Unicode字符�?

匚w��中文字符的正则表辑ּ��Q?[u4e00-u9fa5]

匚w��双字节字�W?包括汉字在内)�Q�[^x00-xff]

应用�Q�计��字�W�串的长度（一个双字节字符长度�?�Q�ASCII字符�?�Q?/p>

String.prototype.len=function(){return this.replace([^x00-xff]/g,"aa").length;}

匚w��I��的正则表辑ּ��Q�n[s| ]*r

匚w��HTML标记的正则表辑ּ��Q?<(.*)>.*|<(.*) />/

匚w��首尾�I�格的正则表辑ּ��Q?^s*)|(s*$)

应用�Q�javascript中没有像vbscript那样的trim函数�Q�我们就可以利用�q�个表达式来实现�Q�如下：

String.prototype.trim = function()
{
return this.replace(/(^s*)|(s*$)/g, "");
}

利用正则表达式分解和转换IP地址�Q?/p>

下面是利用正则表辑ּ�匚w��IP地址�Q��ƈ��IP地址转换成对应数值的Javascript�E�序�Q?/p>

function IP2V(ip)
{
re=/(d+).(d+).(d+).(d+)/g //匚w��IP地址的正则表辑ּ�
if(re.test(ip))
{
return RegExp.$1*Math.pow(255,3))+RegExp.$2*Math.pow(255,2))+RegExp.$3*255+RegExp.$4*1
}
else
{
throw new Error("Not a valid IP address!")
}
}

不过上面的程序如果不用正则表辑ּ��Q�而直接用split函数来分解可能更��单，�E�序如下�Q?/p>

var ip="10.100.20.168"
ip=ip.split(".")
alert("IP值是�Q?+(ip[0]*255*255*255+ip[1]*255*255+ip[2]*255+ip[3]*1))

匚w��Email地址的正则表辑ּ��Q�w+([-+.]w+)*@w+([-.]w+)*.w+([-.]w+)*

匚w��|�址URL的正则表辑ּ��Q�http://([w-]+.)+[w-]+(/[w- ./?%&=]*)?

利用正则表达式去除字串中重复的字�W�的��法�E�序�Q?/p>

var s="abacabefgeeii"
var s1=s.replace(/(.).*1/g,"$1")
var re=new RegExp("["+s1+"]","g")
var s2=s.replace(re,"")
alert(s1+s2) //�l�果为：abcefgi

我原来在CSDN上发贴寻求一个表辑ּ�来实现去除重复字�W�的�Ҏ(gu��)��Q�最�l�没有找刎ͼ��q�是我能惛_��的最��单的实现�Ҏ(gu��)��。思�\是��用后向引用取出包括重复的字符�Q�再以重复的字符建立�W�二个表辑ּ��Q�取��C��重复的字�W�，两者串�q�。这个方法对于字�W�顺序有要求的字�W�串可能不适用�?/p>

得用正则表达式从URL地址中提取文件名的javascript�E�序�Q�如下结果�ؓpage1

s="http://www.9499.net/page1.htm"
s=s.replace(/(.*/){0,}([^.]+).*/ig,"$2")
alert(s)

利用正则表达式限制网��表单里的文本框输入内容�Q?/p>

用正则表辑ּ�限制只能输入中文�Q�onkeyup="value=value.replace(/[^u4E00-u9FA5]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^u4E00-u9FA5]/g,''))"

用正则表辑ּ�限制只能输入全角字符�Q?onkeyup="value=value.replace(/[^uFF00-uFFFF]/g,'')" onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^uFF00-uFFFF]/g,''))"

用正则表辑ּ�限制只能输入数字�Q�onkeyup="value=value.replace(/[^d]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"

用正则表辑ּ�限制只能输入数字和英文：onkeyup="value=value.replace(/[W]/g,'') "onbeforepaste="clipboardData.setData('text',clipboardData.getData('text').replace(/[^d]/g,''))"

肥仔 2008-05-10 22:25 发表评论

VC6中��用STLPort4.6.2

肥仔 — Wed, 07 May 2008 02:53:00 GMT

�~�译��׃��说了, �|�上�q�方面的文章很多

********************************************
如果和PlatformSDK 一起��用的�?br>要记的在STLport目录�?\stlport\stl_user_config.h 文�g�?br>把这一句打开

# 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

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

�Ҏ(gu��)��使用IOSTREAM�? 如果有问�?br>在STLport目录�?\stlport\stl_user_config.h 文�g�?br>把这一句打开�?

# 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++); //�q�里��Z��q�样不出�?而把it++攑֤�面就不行�?br> //在外面是对删除后的无效指针加, 而里面是�Ҏ(gu��)��效指针加
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.

肥仔 2008-05-07 10:53 发表评论

Boost.Python

肥仔 — Fri, 25 Apr 2008 09:54:00 GMT

Boost.Python �?Boost 中的一个组�Ӟ�� 使用它能够大大简化用 C++ �?Python 写扩展库的步骤，提高开发效率，虽然目前它对 Python 嵌入 C++ 的支持还不是很多�Q?但也能提供很大方�ѝ��另外，华宇�?/a>也编写了一份关�?Boost.Python ��明教�E?/a>�?

1 Boost 安装��?/h3>
在正式开始��?Boost.Python 之前�Q?我们必须先编�?Boost�?首先�?Boost 的官方站�?/a> 下蝲 Boost 的源码包�Q?把它们解压到你喜�Ƣ的目录�Q��ؓ�~�译做好准备�?另外�Q?在正式安�?Boost.Python 之前�Q?我们必须先正��安�?Python�?

1.1 Linux 下的�~�译

首先切换�?Boost 源码所在的路径�Q?执行 ./configure 脚本�Q��ؓ配置脚本提供 Python �q�行环境相应的参敎ͼ�

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

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

1.2 使用 MinGW + MSys �?Windows 下的�~�译

首先需要编译的�?Boost 的编译工�?bjam�Q?直接�?bjam 所在目录下�Q?�?Boost 源码包所在目录下�?\tools\build\jam_src�Q?执行 build.bat mingw�Q�稍�{�片刻， bjam.exe ��q��译好了�?把编译好�?bjam.exe 复制��C��?%PATH% 路径能够直接扑ֈ�的地方，为后�l�的�~�译工作做好准备�?

接下来，切换�?Boost 源码所在�\径，执行 bjam �q�行�~�译�?我们需要提供关�?Python 的一些参敎ͼ� 变量 PYTHON_ROOT 指向 Python �q�行环境所在的目录�Q�变�?PYTHON_VERSION 的��gؓ Python 的版本号�Q?如果你的 Python 安装路径与滇狐不同，请将相应的变量修改�ؓ你机器上相应的�\径， �~�译命��o行如下：

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

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

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

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

2.1 修改模块加蝲路径�Q�装�?Python 模块

与�Q何一个其�?Python 嵌入 C/C++ 的程序一��P�� 我们需要在�W�一�?#include 语句处含�?Python.h�Q?�q�在�E�序开始时调用 Py_Initialize()�Q�在�E�序�l�束时调�?Py_Finalize()�?

接下来，我们便可以开始准备装�?Python 模块了�?��Z��?Python 解释器能够正��地扑ֈ� Python 模块所在的位置�Q?我们需要将 Python 模块所在的路径��d��到模块搜索�\径中�Q�添加搜索�\径的 Python 语句如下�Q?pre>import sys if not '/module/path' in sys.path: sys.path.append('/module/path')

我们使用 Python C API 执行�c�M��的语句， ��p��模块的搜烦路径��d��?Python 解释器中�?��d��了搜索�\径后�Q?��可以通过 PyImport_ImportModule 函数加蝲 Python 模块了�?PyImport_ImportModule �q�回值是 PyObject *�Q?��Z��避免手工处理�J�琐的引用计数等问题�Q�我们求助于 Boost.Python 提供�?handle 模块�Q?��?PyObject * ��装��h��Q?以方便��用，代码如下�Q?pre>#include ... 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 模块��存攑֜�当前路径�Q?你也必须使用上面的代码将当前路径��d��到搜索�\径中之后�Q�才能通过 PyImport_ImportModule 加蝲到模块�?

�?Python 模块使用完毕或程序结束时�Q?请��?delete ��?_module 指针释放�Q?handle 被释攄��时候会自动释放相应�?Python 模块�q�回收相应资源�?

2.2 调用 Python 函数

导入�?Python 模块之后�Q?调用 Python 函数��非常容易了�?Boost.Python 里封装了一个非常好用的模板函数 boost::python::call_method�Q�它可以替你处理调用函数旉��要处理的�U�种�l�节�Q?��你�?Python C API 中繁琐的“将参数打包�?PyObject *”�?“构�?Tuple”�?“传�?Tuple”�?“解包返回值”等工作中彻底解攑և�来，你只需要这��P��

    boost::python::call_method<�q�回值类�?gt;(模块指针, "Python 函数�?,
        参数 1, 参数 2, ...);

模块指针可以通过我们前面得到�?_module �?get �Ҏ(gu��)��获得�Q?例如�Q?pre>... 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 �c�d��?/h4>
使用 Python C API 调用 Python 函数和调�?Python �c�d��象是没有太大区别的，我们只需要调用类的构造方法，得到一个类对象�Q?然后把该�cȝ��指针看做模块指针�Q�按照前面调用普通函数的�Ҏ(gu��)��调用�c�L��员方法就可以了�?例如�Q?下列代码�?`_module` 中创��Z��一�?`YukiSession` 对象�Q?然后调用了其中的 `on_welcome` �Ҏ(gu��)��?除了展示调用�c�L��员方法外�Q?�q�段代码�q�展�C�Z��构�?Python list 对象�?�?Python list 对象中获取元素的方式�?pre> ... 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 (param.ptr(), "getitem", 1); ...

3 在嵌入的 Python 模块中调�?C++ �E�序

通过动态链接库的方式��?Boost.Python 导出 C++ 模块�?Python �E�序与在 C++ 可执行程序中导出模块�l�嵌入的 Python 解释器， �~�写�E�序的方式几乎是完全相同的。因此这里只��单介�l�导出普通函数的�Ҏ(gu��)��Q?惌��l�了解更多高�U�功能，如导�?C++ �c�R�?导出可被 Python 重蝲的类�{�，可以参看华宇煜的 Boost.Python ��明教�E?/a>或官�?Boost.Python 文档�?

3.1 导出 C++ 函数

首先使用 BOOST_PYTHON_MODULE 宏定义需要导出给 Python 的模块，然后�?boost::python::def 语句定义导出的函数�?参数列表以及 Doc String�Q?例如在下面的例子中，我们导出了一�?C++ 函数 yukigettext�Q��ƈ重命名�ؓ gettext�Q?pre>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�Q?我们需要在 Py_Initialize() 之后调用�q�个自动生成的函敎ͼ� 初始化导出到 Python 的模块�?例如我们刚才导出模块用的�?BOOST_PYTHON_MODULE(yuki)�Q?因此初始化的时候就应该调用 inityuki()�Q?pre>... Py_Initialize(); inityuki(); ...

3.3 �?Python 模块中调�?C++ 模块

此时我们�?Python 模块中只需要像普通的 Python 模块那样�Q?��导入的 C++ 模块�?import 语句加蝲�q�来�Q?��可以调用了�Q?pre>import yuki ... print yuki.gettext("This is a test!")

肥仔 2008-04-25 17:54 发表评论

对字�W�串�c�d��和数值类型间�q�行转换问题的处理之Boost�l��glexical_cast

肥仔 — Fri, 25 Apr 2008 09:08:00 GMT

在CSDN论坛上经常看到询问如何在字符串类型和数值类型间�q�行转换的问题，也看��C��许多不同的答案。下面先讨论一下从字符串类型到数值类型的转换�?

如何��字�W�串"123"转换为int�c�d��整数123�Q�答案是�Q�用标准C的库函数atoi�Q?
如果要�{换�ؓlong�c�d��呢？标准C的库函数atol�Q?
如何��?123.12"转换为double�c�d��呢？标准C的库函数atod�Q?
如果要�{换�ؓlong double�c�d��呢？标准C的库函数atold�Q?
…�?

后来有朋友开始��用标准库中的string�c�，问这个如何�{换�ؓ数��|��有朋友答曎ͼ�请先转换为const char*。我很佩服作�{�者有数学家的思维�Q�把陌生的问题�{化成熟�?zh��n)�的问题。（曄��有一则笑话，好事者问数学�Ӟ��知道如何烧水吗？�{�：知道。把水壶加满��_��点火烧。又问：如果水壶里已�l�有水了呢？�{�：先倒掉�Q�就转化为我熟�?zh��n)�的问题了……）

不，不，�q�样是C的做法，不是C++。那么，C++该怎么做呢�Q��用Boost Conversion Library所提供的函数l(f��)exical_cast�Q�需要引入头文�gboost/lexical_cast.hpp�Q�无疑是最��单方便的。如�Q?

#include 
#include 
int main()
{
        using boost::lexical_cast;
        int a = lexical_cast("123");
        double b = lexical_cast("123.12");
        std::cout<
一个函数就����z�地解决了所有的问题�?

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

#include 
#include 
#include 
int main()
{
        using std::string;
        const double d = 123.12;
        string s = boost::lexical_cast(d);
        std::cout<
跟前面一��L��单�?
3.3 异常 
如果转换��p�|�Q�则会有异常bad_lexical_cast抛出。该异常�c�L��标准异常�c�bad_cast的子�c�R�?
#include 
#include 
int main()
{
        using std::cout;
        using std::endl;
        int i;
        try{
                i = boost::lexical_cast("abcd");
        }
        catch(boost::bad_lexical_cast& e)
        {
                cout<
昄���“abcd”�ƈ不能转换��Z��个int�c�d��的数��|��于是抛出异常�Q�捕捉后输出“bad lexical cast: source type value could not be interpreted as target”这��L��信息�?
3.4 注意事项 
lexical_cast依赖于字�W�流std::stringstream�Q�会自动引入头文�?a >4�Q�，其原理相当简单：把源�c�d����d��到字�W�流中，再写到目标类型中�Q�就大功告成。例�?
int d = boost::lexical_cast("123");
���q��当于 
int d;
std::stringstream s;
s<<"123";
s>>d;
既然是��用了字符���，当然���有些随之而来的问题，需要特别指�?a >5�?

�׃��Visual C++ 6的本地化�Q�locale�Q�部分实现有问题�Q�因此如果��用了非默认的locale�Q�可能会莫名其妙地抛出异常。当�Ӟ��一般情况下我们�q�不需要去改变默认的locale�Q�所以问题不是很大�?
输入数据必须“完整”地转换�Q�否则抛出bad_lexical_cast异常。例�?
int i = boost::lexical_cast("123.123"); // this will throw 
便会抛出异常。因为�?23.123”只能“部分”地转换�?23�Q�不能“完整”地转换�?23.123�?

���点数的�_�ֺ�问题�?
std::string s = boost::lexical_cast(123.1234567);
以上语句预想的结果是得到�?23.1234567”，但是实际上我们只会得到�?23.123”，因�ؓ默认情况下std::stringstream的精度是6�Q�这是C语言�E�序库中的“前辈”printf留下的传�l�）。这可以说是boost::lexical_cast的一个bug。怎么办呢�Q�权宜之计，可以�q�么做：打开头文�?lt;boost/lexical_cast.hpp>�Q�注意对照修�?a >6�Q?
#include 
//...
template
Target lexical_cast(Source arg) {
        //...
        Target result; 
        interpreter.precision(std::numeric_limits::digits10);
        if( !(interpreter << arg) ||
        !(interpreter >> result) ||
        !(interpreter >> std::ws).eof())
        //...
}
卛_��得到正确�l�果。当�Ӟ��理论上效率会有一点点损失�Q�不�q�几乎可以忽略不计�?
4 ���结 

我们已经体验了boost::lexcial_cast。当�Ӟ��lexical_cast不仅仅局限于字符串类型与数值类型之间的转换�Q�可在�Q意可输出到stringstream的类型和��L��可从stringstream输入的类型间转换。这�ơ的了解���管很粗略，不过毕竟我们已经“走�q�Boost”，而不仅仅是“走�q�”。以后，我们可以自行领略Boost的动��Z��处啦�?


肥仔 2008-04-25 17:08 发表评论

STLPort 5.1.5 �~�译

肥仔 — Thu, 24 Apr 2008 16:56:00 GMT

STLPort 5.1.5 下蝲

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

Bat文�g

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

肥仔 2008-04-25 00:56 发表评论

boost bat

肥仔 — Thu, 24 Apr 2008 10:53:00 GMT

SET INCLUDE=\"D:\\STLport-4.6.2\\stlport\";%INCLUDE%
SET LIB=\"D:\\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
rem pause
cd c:\Program Files\Microsoft Visual Studio\VC98\bin
pause
call VCVARS32.BAT
pause
cd C:\boost_1_33_1\libs\regex\build
pause
rem call nmake -f vc6-stlport.mak
pause
cd C:\boost_1_33_1
pause
rem bjam -sBOOST_ROOT=. -sTOOLS=msvc --with-thread stage
rem msvc-stlport-tools
bjam -sBOOST_ROOT=. -sTOOLS=msvc-stlport --with-thread stage
rem quit
exit

rem 版本�Q�boost 1.33.1 STLport 5.0 / VS.net 2003 没有�Ҏ(gu��)��讄��Q�除了程序的debug build应加_STLP_DEBUG宏定义�?br>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

肥仔 2008-04-24 18:53 发表评论

boost �~�译

肥仔 — Fri, 18 Apr 2008 17:55:00 GMT

Boost历史版本下蝲地址

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

bat文�g�Q�boost 1.33.1 Python 2.2.1,可能需要重新安装stl port, stl port版本有问�?nbsp;

::如果不要�~�译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文�g�Q�可以搜索得�?br>::--with-thread是只�~�译thread库，--without-thread则相�?br>::比如�~�译thread 的lib库如下行.
rem bjam -sBOOST_ROOT=. -sTOOLS=msvc --with-thread stage

::�~�译所�?br>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�Q�解压到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�Q�执行：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文�g夹（里面是源代码�Q�lib_source�Q�，拯��到C:\Boost�Q��ƈ更改名�ؓboost_src,�q�样��成了C:\Boost\boost_src

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

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

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

12、C:\boost_1_35_0�q�个文�g夹可以删除了�Q�如果不惛_��除，那么C:\boost_1_35_0\bin.v2�q�个是编译时候的obj�{�文�Ӟ��可以删除掉�?

�q�行出现的错�?

1、预定义头要加入�Q?D_STLP_DEBUG,__STL_DEBUG

2、ZM limit 错误�Q�工�E?>讄��->C/C++选项卡下面有“工�E�选项”的一个命令区在命令行的末��֊��?Zm1000�Q�改�?Zm2000也行�Q�是整百的都可以

3、“compiler is out of heap space”，\ZM�Ҏ(gu��)��2000(最大了)

4、“Fatal   Error   C1063”，�q�个错误是编译器栈溢出，可能是你的程序单个源文�g太大了，拆分成小一些的文�g试试
      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�Q�STLPort�~�译�Q�或�?nmake -f vc6.mak�Q�普通编译）

用来��试的代码，建立一个Win32 Console Application�Q?

#include "stdafx.h"
#include
#include
#include
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;
}

如果一切顺利通过�Q�恭喜你�Q�boost安装成功�?

vc6 上安装stlport和boost�?/a>

1
vc 6 sp5补丁预处理补�?br>python2.2.3
stlport4.5.3
boost1.3.0.2
2
使用stlport的iostream�Q�boost.python�~�译��p�|
如果��用stlportt的iostream�Q�boost.regex�~�译��p�|
选择boost1.3.0.2的原�?
�?br>http://engineering.meta-comm.com/boost.aspx
得知Boost-wide regression reports
vc6基本支持boost1.3.0.2 的全部库
而boost以后的版本，vc6 的表现可以说是惨不忍睏V�?br>boost1.3.0.2支持 python2.2 stlport 4.5.3
基本��是�q�个样子了�?/p>

肥仔 2008-04-19 01:55 发表评论

亚洲欧美日韩综合一区,亚洲视频中文,亚洲欧洲在线播放

STLPORT的bug

stlport的link error

std::find用法错误记录

STLPort 的预定义

STL容器

iterator�Ҏ(gu��)��值加减的分别

容器.size()�q�回size_t�Q�的注意事项

容器相等�Q�可�q�行直接判断

std::sort多关键字排序

条款9�Q�在删除选项中仔�l�选择

STL 查找���法

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

Example

equal_range()

EffectiveSTL�Q�Item16�Q�如何将vector和string的数据传�l�传�l�的API函数

VC6中��用STLPort4.6.2

Boost.Python

1.1 Linux 下的�~�译

1.2 使用 MinGW + MSys �?Windows 下的�~�译

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

2.1 修改模块加蝲路径�Q�装�?Python 模块

2.2 调用 Python 函数

3 在嵌入的 Python 模块中调�?C++ �E�序

3.1 导出 C++ 函数

3.2 �?Python 初始�?C++ 模块

3.3 �?Python 模块中调�?C++ 模块

对字�W�串�c�d��和数值类型间�q�行转换问题的处理之Boost�l��glexical_cast

3.3 异常

3.4 注意事项

4 ���结

STLPort 5.1.5 �~�译

boost bat

boost �~�译

STL 查找��法

`equal_range()`

4 ��结