USE     tablename             -- 要操作的数据库名
SELECT  @LogicalFileName = 'tablename_log',  -- 日志文件名
@MaxMinutes = 10,               -- Limit on time allowed to wrap log.
        @NewSize = 1                  -- 你想设定的日志文件的大小(M)
-- Setup / initialize
DECLARE @OriginalSize int
SELECT @OriginalSize = size
  FROM sysfiles
  WHERE name = @LogicalFileName
SELECT 'Original Size of ' + db_name() + ' LOG is ' +
        CONVERT(VARCHAR(30),@OriginalSize) + ' 8K pages or ' +
        CONVERT(VARCHAR(30),(@OriginalSize*8/1024)) + 'MB'
  FROM sysfiles
  WHERE name = @LogicalFileName
CREATE TABLE DummyTrans
  (DummyColumn char (8000) not null)

DECLARE @Counter   INT,
        @StartTime DATETIME,
        @TruncLog  VARCHAR(255)
SELECT  @StartTime = GETDATE(),
        @TruncLog = 'BACKUP LOG ' + db_name() + ' WITH TRUNCATE_ONLY'
DBCC SHRINKFILE (@LogicalFileName, @NewSize)
EXEC (@TruncLog)
-- Wrap the log if necessary.
WHILE     @MaxMinutes > DATEDIFF (mi, @StartTime, GETDATE()) -- time has not expired
      AND @OriginalSize = (SELECT size FROM sysfiles WHERE name = @LogicalFileName) 
      AND (@OriginalSize * 8 /1024) > @NewSize 
  BEGIN -- Outer loop.
    SELECT @Counter = 0
    WHILE  ((@Counter < @OriginalSize / 16) AND (@Counter < 50000))
      BEGIN -- update
        INSERT DummyTrans VALUES ('Fill Log') 
        DELETE DummyTrans
        SELECT @Counter = @Counter + 1
      END  
    EXEC (@TruncLog) 
  END  
SELECT 'Final Size of ' + db_name() + ' LOG is ' +
        CONVERT(VARCHAR(30),size) + ' 8K pages or ' +
        CONVERT(VARCHAR(30),(size*8/1024)) + 'MB'
  FROM sysfiles
  WHERE name = @LogicalFileName
DROP TABLE DummyTrans
SET NOCOUNT OFF
8、说明：更改某个表
exec sp_changeobjectowner 'tablename','dbo'
9、存储更改全部表
CREATE PROCEDURE dbo.User_ChangeObjectOwnerBatch
 @OldOwner as NVARCHAR(128),
 @NewOwner as NVARCHAR(128)
AS
DECLARE @Name   as NVARCHAR(128)
DECLARE @Owner  as NVARCHAR(128)
DECLARE @OwnerName  as NVARCHAR(128)
DECLARE curObject CURSOR FOR
 select 'Name'   = name,
  'Owner'   = user_name(uid)
 from sysobjects
 where user_name(uid)=@OldOwner
 order by name
OPEN  curObject
FETCH NEXT FROM curObject INTO @Name, @Owner
WHILE(@@FETCH_STATUS=0)
BEGIN    
 if @Owner=@OldOwner
 begin
  set @OwnerName = @OldOwner + '.' + rtrim(@Name)
  exec sp_changeobjectowner @OwnerName, @NewOwner
 end
-- select @name,@NewOwner,@OldOwner
 FETCH NEXT FROM curObject INTO @Name, @Owner
END
close curObject
deallocate curObject
GO

10、SQL SERVER中直接循环写入数据
declare @i int
set @i=1
while @i<30
begin
   insert into test (userid) values(@i)
   set @i=@i+1
end
小记存储过程中经常用到的本周，本月，本年函数
Dateadd(wk,datediff(wk,0,getdate()),-1)
Dateadd(wk,datediff(wk,0,getdate()),6)
Dateadd(mm,datediff(mm,0,getdate()),0)
Dateadd(ms,-3,dateadd(mm,datediff(m,0,getdate())+1,0))
Dateadd(yy,datediff(yy,0,getdate()),0)
Dateadd(ms,-3,DATEADD(yy, DATEDIFF(yy,0,getdate())+1, 0))
上面的SQL代码只是一个时间段
Dateadd(wk,datediff(wk,0,getdate()),-1)
Dateadd(wk,datediff(wk,0,getdate()),6)
就是表示本周时间段.
下面的SQL的条件部分,就是查询时间段在本周范围内的:
Where Time BETWEEN Dateadd(wk,datediff(wk,0,getdate()),-1) AND Dateadd(wk,datediff(wk,0,getdate()),6)
而在存储过程中
select @begintime = Dateadd(wk,datediff(wk,0,getdate()),-1)
select @endtime = Dateadd(wk,datediff(wk,0,getdate()),6)

多态， 事实上，这是 Template Method模式的关键
2. 关于成员变量初始化顺序，几个有依赖关系的成员变量要初始化，让写出构造函数。

在初始化列表中，成员变量的初始化顺序是其在类中声明顺序，而非列表中的顺序。

3. 写一个双链表。

Struct ListNode

{

    int nData;

    ListNode* pPreviousNode;

    ListNode* pNextNode;

}

一般链表都会有一个表头节点与指向表头节点的头指针， 应该会提供列表接口， 按此数据结构实现即可。

4. 写个is-a和has-a。

这个比较简单

Class Pet{};

Class Dog: public Pet{};

Class Boy{Pet* m_pPet;};

5. struct vs. class.

1)默认访问属性， struct为public, class为private

2) 默认继承属性，struct为public, class为private
3)class可以用来声明模板参数，而struct不能

6. 称8个小球的问题

没题

7. stl 里面vector的实现（内部空间的申请与分配）

Vector中文名字是动态数组， 其内部数据结构就是一个数组， 但是在数组元素不够用的时候，就要动态的重新分配， 一般是现在大小的两倍， 然后把原数组的内容拷贝过去。所以， 在一般情况下， 其访问速度同一般数组， 只有在重新分配发生时， 其性能才会下降

8. struct /class的区别

重复了

9. 为什么要用struct

成员的默认属性不同，用struct的话，主要是作为数据的集合。

10. 怎样使一个class不能被实例化

1，构造函数私有化，2，抽象类

11. 私有继承和public继承的区别。

私有继承： 只继承实现，不继承实现 has-a

公有继承：继承接口与实现    is-a

12. void *p的问题

不能++

13. 引用和指针的区别与联系。引用是否可以更改

联系： 支持多态，可以用来引用同一对象

区别：指针可以为NULL， 引用不可以； 指针可以重赋值， 引用不可以；

14. windows编程基础，线程与进程的区别

程序是一系列静态的指令序列

进程是程序的一次动态执行，进程其实是一个资源的容器，包括一个私有的虚拟地址空间，一些初始的代码与数据， 一些系统资源的句柄等

线程是一个进程中的执行体， 一般包括CPU寄存器状态，两个栈（内核模式，用户模式）以及一个TLS(Thread-Local Storage)等

15. com+是否熟悉

COM+是COM技术的延伸与发展， 它包括了所有COM的基本功能（基于接口的编程模型，基本组件服务），并组合了DCOM（使组件技术延伸到了分布式领域）和MTS-Microsoft Transaction Server（提供了服务器端的组件管理与配置管理），并新增了一些服务：负载平衡，内存数据库，事件模型，队列服务等，主要用于Windows DNA(Distributed interNet Application Architecture)三层结构的中间层。

16. 简述一下hash算法

哈希表的目的是表查询插入修改能够达到O(1)的算法复杂度， 通过对key编码来确定其存储地址来实现， 当不同的key得到相同的编码时，便需要进行冲突检测与处理，一般方法有除留余数法， 线性探测法，平方探测法， 这使其无法真正达到O(1)

17. 一个32位的数据，怎样找到最左边的一个1？

如果是在最左位，这个数是负数，否则的话，左移一位，看是否变成负数，这是O(n)的算法， 也可以用一个模板去与，并不断改变这个模板

O(n/2)的算法：二分方式查找 ？？？

18. 一个4*4的格子，填入1~15 然后给个目标状态，怎样去搜索。
比如：
 1   2  3    6
 0   4  5    7
 8   9  10 11
12 13 14 14

再给出个最终的状态 （随便都可以）
0 表示一个空格，可以移动，有点像拼图； 

人工智能的教材上用的应该就是这个例子，用A*算法，它既不是广度搜索，也不是深度搜索，而是一种启发式搜索，在进行下一步搜索之前，会用一个估价函数来对后面的节点评分， 取评分最优的进行下一步搜索，如果找不到结果，回溯。对于本题，用曼哈顿距离作为评分标准是个不错的选择。

19. 给你100万个数据，数据的值在0~65535之间 用最快的速度排序

多关键字基数排序MSD(MOST SIGNIFICANT DIGIT FIRST)

20. 如果我们的一个软件产品，用户回复说：运行速度很慢，你怎么处理？

询问其Workflow, 用户的硬件环境

21. 八皇后问题，详述解法 （八皇后问题说的是在8*8国际象棋棋盘上,要求在每一行放置一个皇后,且能做到在竖方向,斜方向都没有冲突）

回溯法

22. kmp快速匹配算法 ---不算轻松的搞定

普通的模式匹配算法，一旦不匹配，模式串右移一位；但是其实根据一直条件，我们可以算出应该向右移几位以避免不必要的比较；算法实现比较曲折

23. 无向图中两点间最短路问题 ---伟大的迪杰克斯拉算法

假设一共有N个节点， 需要一个一维数组Previous[N]来记录前一个节点序号；一个一维数组TotalLength[N]来记录从原点到当前节点最短路径；一个二维数组Weights[N][N]来记录各点之间边的权重(如果存在)， 然后从源点到终点进行深度搜索或广度搜索， 按以下规则：搜索到某个节点b时，假设其前一个节点为a, 把TotalLength[a] + Weights[a][b]与TotalLength[b]相比较，如果小于TotalLength[b]， 则TotalLength[b] = TotalLength[a] + Weights[a][b], Previous[b] = a; 反之则不做任何操作。这样到搜索结束后， 从Previous[N]数组中就能得到整条最短路径了

24. 空间中任意给两个向量，求角平分线

先单位化， 假设单位化后结果为nv1, nv2, 则角平分线为(nv1+nv2) / 2

25. 什么是平衡树

左右子树都是平衡树，且高度相差不超过1的有序二叉树

26. 哈夫曼编码问题

理论基础:霍夫曼树是带权路径长度（WPL：Weighted Path Length）最小的二叉树，它不一定是完全二叉树，应该是权值大的外结点离根节点最近的扩充二叉树。霍夫曼编码是为了实现数据的最小冗余编码，是数据压缩学的基础。 它根据字符在电文中出现的频率为权值，构造霍夫曼树，左为0， 右为1. 其有两个效果，一是保证电文有最短的编码，二是字符间不需要分隔符，因为不同的字符必定有不同的开头（成为前缀编码）。

27. 有向图求环

以该节点为源点与终点吗进行深度优先或广度优先搜索

28. .给n个点，求凸包问题

凸包(convex hull)是指一个最小凸多边形，满足这N个点都在多边形上，或其内。算法描述：

求出最右的那个点作为凸多边形的一个顶点(P0)，遍历其他所有点(Pi)， 如果其他点都在向量P0Pi的同一侧，则Pi也为凸多边形的顶点。

29. 四则运算（给一个前缀表达式（波兰式）或后缀表达式(逆波兰式)，然后求解；给一个中缀表达式）

+*-CDBA -/EF---------------------> A+B*(C-D)-E/F       前缀-中缀

操作符进栈，一个变量tmp放上一个中间操作数（运算结果），遇到操作数检查tmp是否为空， 空的话取两个操作数，不空的话取一个操作数，另一个就是tmp了，操作符出栈运算，结果放入tmp中，如果是操作符，tmp清空

 ABCD-*+EF/- ---------------------> A+B*(C-D)-E/F     后缀-中缀

操作数进栈，遇到操作符，两个操作数出栈，计算结果入栈

30. STL中container有哪些？

序列容器： vector, list, deque, bitset

关联容器:     set, multiset, map, multimap

适配容器：stack, queue, priority_queue

类容器:         string, valarray, bitset

扩展容器：hash_set, hash_multiset, hash_map, hash_multimap

31. map中的数据存储方式是什么？

红黑树， 是一种平衡二叉搜索树， 具有良好的最坏情况运行时间（统计性能好与AVL树）

32. map和hashmap有什么区别？

内部数据结构不同， map是红黑树，hashmap是哈希表

33. hashmap是标准库中的吗？

不是的，但在SGI stl与vc2005中都提供了。

34. vector中的erase方法跟algorithm的remove有什么区别？

vector中erase是真正删除了元素， 迭代器访问不到了。 algorithm中的remove只是简单的把要remove的元素移到了容器最后面，迭代器还是可以访问到的。因为algorithm通过迭代器操作，不知道容器的内部结构，所以无法做到真正删除。

35. object是什么？

具有内部状态，以及操作的 软件构造，用来表示真实存在（物理上或概念上）的对象

36. C++中如何阻止一个类被实例化？

纯虚函数；构造函数私有化（友元）

37. 一般在什么时候构造函数被声明成private呢？

 singleton模式； 阻止某些操作（如阻止拷贝构造）

38. 什么时候编译器会生成默认的copy constructor呢？

用户没有自定义copy constructor；在代码中使用到了copy constructor;

39. 如果你已经写了一个构造函数，编译器还会生成copy constructor吗？

如果我写的是copy constructor, 不会

如果我写的不是copy constructor, 同38

40. 为什么说如果一个类作为基类，则它的析构函数要声明成virtual的？

因为，如果delete一个基类的指针时， 如果它指向的是一个子类的对象，那么析构函数不为虚就会导致无法调用子类析构函数，从而导致资源泄露。 当然，另一种做法是将基类析构函数设为protected.

41. inline的函数和#define有什么区别？什么时候会真的被inline，什么时候不会呢？

1) 宏是在预编译阶段简单文本替代， inline在编译阶段实现展开

2)宏肯定会被替代，而复杂的inline函数不会被展开

3)宏容易出错（运算顺序），且难以被调试,inline不会

4)宏不是类型安全，而inline是类型安全的，会提供参数与返回值的类型检查

当出现以下情况时inline失败

函数size太大

inline虚函数

函数中存在循环或递归

函数调用其他inline函数

42. 如果把一个类的成员函数写在类的声明中是什么意思？

inline此函数 （inline与template类似， 必须在.h中实现）

43. public继承和private继承有什么架构上的区别？

public是is-a的关系，继承接口与实现

private是has-a的关系 ，只继承实现

44. 在多继承的时候，如果一个类继承同时继承自class A和class B，而class A和B中都有一个函数叫foo()，如何明确的在子类中指出override哪个父类的foo()？

首先，foo在A,B总应该都是虚函数，否则就直接覆盖了，就没有这个问题了；其次，这个问题从语法角度来看似乎是无法解决。因为我们不能改原有设计（不然也没这个问题了:)）,所有只好从extend来考虑：

class EA: public class A

{

public:

   virtual void foo(){fooA();}

private:

   virtual void fooA() = 0;

}

class EB: public class B

{

public:

   virtual void foo(){fooB();}

private:

   virtual void fooB() = 0;

}

这样， 我就可以override不同的函数来达到这个目的了

class AB: public EA, pubic EB

{

private:

virtual void fooA(){}

virtual void fooB(){}

}

45. 虚拟继承的语法是什么？

    A

 /     \

B      C

   \ /

    D

class A{};

class B: virtual public A{};

class C: virtual public A{};

class D: public B, public C{};

46. 部分模版特例化和全部模版特例化有什么区别？

偏特化只使用于类模板，而全特化适用与函数模板，类模板。

偏特化的结果还是一个模板，而全特化的结果是一个具体的类型。

47. 编一个函数，使一个单项链表转置。

应该是逆序吧

这个小算法竟然花了我不少时间，没有测试过的：

48. 拆解一个整数，比如4,可以拆解成4=3+1；4=2+2；4=2+1+1；4=1+1+1+1

首先，对一个数进行拆分后，可能又要对最后一个因子进行拆分，所以要用递归；其次，第n+1个因子是小于等于第n个因子的；再者，对最后一个因子，我可以直接输出，也可以继续拆分。

算法如下：

唉，老了，这个小东西搞了我N久的。。。。

49. 不用库函数，实现strcpy或者memcpy等函数

一个字节一个字节的拷过去吧，但是要考虑源内存与目标内存的重叠。

50. 内联函数的作用和缺点

把代码直接插入到调用的地方，可以减少函数调用的次数，但是会增加代码的size，还有，如果内联失败，在每个调用的obj里，都会产生一份该函数的拷贝，这样既没有怎么减少代码的size，又没有减少函数的调用，赔了夫人又折兵。。。

51. 指针和引用的区别

指针可以不初始化，引用必须初始化

指针可以是NULL，而引用必须引用一个实在的对象

指针可以重指向其他对象，引用一旦初始化，便不再改变

52. 友元的意义

使被声明为友元的函数或类可以访问某个类的非共有成员。

53. 虚函数的意义

实现多态

54. Overload, Overwrite, Override 各自的特点和意义

Overload: 函数重载(名字相同，参数不同)

Overwrite：覆盖

Override: 虚函数重载

55. 头文件中的ifndef/define/endif 干什么用？

防止该头文件被重复引用。

56. ＃i nclude <filename.h> 和＃i nclude “filename.h” 有什么区别？

＃i nclude <filename.h>： 从标准库路径去寻找该文件，对于VC来说，应该还包括VC环境设置选项中的包含目录以及工程属性中指定的目录

＃i nclude “filename.h”：先在当前目录查找，如果找不到，按上面那种方式寻找

57. 在C++ 程序中调用被C 编译器编译后的函数，为什么要加extern “C”？

C++语言支持函数重载，C 语言不支持函数重载。函数被C++编译后在库中的名字与C 语言的不同。C++提供了C 连接交换指定符号extern“C”来解决名字匹配问题

58. 一个类有基类、内部有一个其他类的成员对象，构造函数的执行顺序是怎样的？

先执行基类的（如果基类当中有虚基类，要先执行虚基类的，其他基类则按照声明派生类时的顺序依次执行），再执行成员对象的，最后执行自己的。

59. 请描述一个你熟悉的设计模式

这个看你熟悉什么了。singleton最简单了，template method用的最多了，bridge挺炫的，command吹吹undo,redo也不错。。。。。

60. 在UML 中，聚合(aggregation)和组合(composition)有什么区别？

其实从名字就能分别出来了。

聚合表示只是简单的聚聚，没什么本质的联系，所以这些对象的生存时间也就没什么关系了；

组合表示了更加紧密的一种关系，这些对象有着共同的生存期。

一个典型的例子是孙悟空，手臂，金箍棒的关系。。。。

61. C#和C++除了语法上的差别以外，有什么不同的地方？

C++是直接生成可执行代码，而C#是先生成中间代码，等到第一次执行时，才由JIT（Just In Time）生成可执行的机器码。

还有就是(1) c#有垃圾自动回收机制，程序员不用担心对象的回收。(2)c#严禁使用指针，只能处理对象。如果希望使用指针，则仅可在unsafe 程序块中能使用指针。(3)c#只能单继承。(4)必须通过类名访问静态成员。不能像C++中那样，通过对象访问静态成员。(5)在子类中重写父类的虚函数时必须用关键字override,覆盖父类的方法要用关键字new

62. New delete与malloc free 的区别

对于类，New 和delete会调用构造，析构函数

new，delete都是能感知到类型的。new返回一个制定的类型，delete删除一个指定的类型，从而不用给定size。而malloc与free都是处理void类型的。用时时必须经过强制类型转换。

63. #define DOUBLE(x) x+x，i = 5*DOUBLE(10)；i是多少？正确的声明是什么？

I = 5*10+10 = 60 60

正确的声明是：

#define DOUBLE(x) ((x)+(x))

64. 有哪几种情况只能用intialization list 而不能用assignment?

当类中含有const、reference 成员变量；基类的构造函数都需要参数；类中含有其他类的成员对象，而该类的构造函数都需要参数。

65. C++是不是类型安全的？

不是。两个不同类型的指针之间可以强制转换。C#是类型安全的。

66. main 函数执行以前，还会执行什么代码？

全局对象的构造函数会在main 函数之前执行。

67. 描述内存分配方式以及它们的区别。

（1）从静态存储区域分配。内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static 变量。

（2） 在栈上创建。在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集。用的是cache，速度较快但容量较小。

（3） 从堆上分配，亦称动态内存分配。程序在运行的时候用malloc 或new 申请任意多少的内存，程序员自己负责在何时用free 或delete 释放内存。动态内存的生存期由我们决定，使用非常灵活，但问题也最多。

 （4）文字常量区， 如char* p = "hello, world"就是一个例子，其内存也在程序编译的时候就已经分配好？

  一个程序除了上面这些，还有一个(5)程序代码区了。

68. 比较一下C++中static_cast 和 dynamic_cast 的区别。

Static_cast可以显式的做一些自动转换，如一些int, char一些基础类型的转换，以及指针之间的转换。但是其不保证安全性。Dynamic_cast主要作用其实在于把一个基类指针转化为子类指针，因为这个基类指针真正指向的不一定是我们想转换的类型的对象，所以转换可能失败，dynamic_cast能够知道失败而返回NULL，而static_cast就没那么聪明了，原因是dynamic_cast会利用rtti去查找该转换是否可行.(耗费时间多点。)

69. 当一个类A 中没有生命任何成员变量与成员函数,这时sizeof(A)的值是多少，如果不是零，请解释一下编译器为什么没有让它为零。

不为零，不同的对象应该有不同的地址，假设我声明一个A的数组A a[2]，如果为零，那么a[0]和a[1]的地址岂不相同了

70. 已知两个链表head1 和head2各自有序，请把它们合并成一个链表依然有序，要求用递归方法进行。

归并排序，应该比较简单。要注意的是如果一个链表为空，那么可以简单的把另一个直接链过去了。

    我爱你，不是因为你是一个怎样的人，而是因为我喜欢与你在一起时的感觉。

    (2) No man or woman is worth your tears, and the one who is, won‘t make you cry.

    没有人值得你流泪，值得让你这么做的人不会让你哭泣。

    (3) The worst way to miss someone is to be sitting right beside them knowing you can‘t have them.

    失去某人，最糟糕的莫过于，他近在身旁，却犹如远在天边。

    (4) Never frown, even when you are sad, because you never know who is falling in love with your smile.

    纵然伤心，也不要愁眉不展，因为你不知是谁会爱上你的笑容。l+cvz

    (5) To the world you may be one person, but to one person you may be the world.

    对于世界而言，你是一个人；但是对于某个人，但是对于某个人，你是他的整个世界。

    (6) Don‘t waste your time on a man/woman, who isn‘t willing to waste their time on you.

    不要为那些不愿在你身上花费时间的人而浪费你的时间。

    (7) Just because someone doesn’t‘t love you the way you want them to, doesn’t‘t mean they don‘t love you with all they have.

    爱你的人如果没有按你所希望的方式来爱你，那并不代表他们没有全心全意地爱你。

    (8) Don‘t try so hard, the best things come when you least expect them to.f.H0

    不要着急，最好的总会在最不经意的时候出现。

    (9) Maybe God wants us to meet a few wrong people before meeting the right one, so that when we finally meet the person, we will know how to be grateful.;

    在遇到梦中人之前，上天也许会安排我们先遇到别的人；在我们终于遇见心仪的人时/数据恢复，便应当心存感激。

    (10) Don‘t cry because it is over, smile because it happened.

    不要因为结束而哭泣，微笑吧，为你的曾经拥有。

    人所拥有的「最后的」（last）自由是，我们可以选择我们的态度。

    有一位老人，独自住在家里。他的儿女轮流回来照顾他。后来觉得最好还是住到老人院去比较好，因为他的眼睛已经完全看不见了。 

    迁入老人院的那一天，服务员牵着他的手告诉他，房间的样子，墙上的壁画，窗户外面是一大片草地，还有水池，这位老人回答说，真的好美，我想我在这里会很开心。服务员瞪着他，一脸讶异的说，你什么都看不见，你怎么知道美不美呢？ 
 
    讲到这里，你大概已经知道这故事想要说的是什么了？ 

    我们比那位老人的情况好多了。我们每天早上起来的时候有没有这么振奋，这么积极？ 

    办公室里的事好像永远都做不完。烦恼的事不知道为什么总是那么多。房子、车子、小孩的学业，今天的早饭该吃什么，这些事从未间断过，就待会儿出门，从车子开出去到抵达停车场，至少会发三次火：有人换车道没打信号灯；某段路塞车因为有人在路边并排停车；再有就是乱按喇叭。 

    想到这里，怪不得我们真的要做一选择。选择今天我要找到美好的事，还是要专注于烦恼的事。我们要选择感恩、宽容，抑或是要让抱怨、愤怒来折磨我。我们甚至可以在今天选择关心他人，对他人感兴趣的机会，而不要让冷漠习惯性的在心头。 

    30年前，我对当时的工作非常不满，时常抱怨，也多次口头叫嚷要辞职。有一天一位其它部门的年长主管跟我说，永远不要因为这个工作不好而辞职，一定要因为另一个工作更好而辞职。
 
    这二句话对我很重要。影响也很大。卅年后的今天，回想起来，他说的真的很有道理。 

    现在的公司制度不好，下一个工作机构的体制多半也有缺陷。现在的公司不公平，谁能保证新的公司一切都很合理公道。现在的公司有派系，天知道多少公司有同样的权力斗争问题。跟现在的主管处不好，新工作的主管就一定处得好吗？ 

    因而换工作不是解决办法。
 
    根本的办法是改变态度。曾在集中营里住过，遭受过人类最悲惨的折磨的奥地利心理学家Victor Frankel就认为，人所拥有的「最后的」（last）自由是，我们可以选择我们的态度。遭遇同样的打击，有的人选择的是绝望，有的人却选择了希望。 

    朋友，你选择的是什么？你准备怎样过这一天？

从 STL 出现到现在已经这么多年了，泛型算法是它的重要组成，也是其中最“看起来很美”的东西之一。然而在真实的程序设计中，它往往成为程序员的心头一痛，因为一旦要用 for_each ，accumulate 之类的算法做一些稍微复杂一点的事情，你就会发现自己一个头变成两个大。即便是有了 boost::bind 和 boost.lambda 的帮助，事情也仍然是扑朔迷离，求助于 comp.lang.c++ 虽然有用，但是又何尝不是一种无奈。好了，现在我开始收集一些来自 comp.lang.c++(.moderated) 的解答，希望日后对自己和他人有用。

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

预备问题（算是第0个问题吧）：如何对一个 STL 容器内的所有元素做某件事情？

这取决于你要做什么，以及容器是什么。如果是 vector, list 这样的容器，而你要把它们全部 cout 出来，当前的标准 STL 解法是这样的：

#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>
#include <string>

int main()
{
  std::vector<std::string> vect;
  vect.push_back("Hello");
  vect.push_back(", ");
  vect.push_back("world!");
 
  std::copy( vect.begin(), vect.end(),
    std::ostream_iterator<std::string>(std::cout) );
}

基本上，这算是一个“过得去”的方案，但是有点问题：
1. 对于不熟悉这个固定用法的人，cout 所有元素所首要考虑算法是 for_each，而不是 copy ，事实上，for_each 也是最符合我们惯常逻辑的算法，因为在不使用 STL 算法的时候，我们使用 for 循环来干这件事。
2. 可读性不太良好，ostream_iterator 的使用有点 tricky ，而且也不能用于做其他的事情。

我想熟悉 boost  的人已经知道我下面要说什么了，因为用 boost.lambda 做这件事情的确非常漂亮：

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace boost::lambda;

int main()
{
  std::vector<std::string> vect;
  vect.push_back("Hello");
  vect.push_back(", ");
  vect.push_back("world!");
 
  std::for_each( vect.begin(), vect.end(), std::cout << _1 );
}

这和前面的程序一样，输出我们熟悉的 Hello, world! 。直观、优雅而且容易修改，例如，如果你不是想要输出它们的值，而是想要输出它们的长度，只需要做很少的修改：

std::for_each( vect.begin(), vect.end(), std::cout << bind(&std::string::length, _1) << "\n" );

输出
5
2
6

bind 的作用是把 lambda 表达式绑定到一个函数或者一个数据成员，在这里的意思，就是对于每一个 string ，都调用其 length() 方法。_1 同样也可以成为赋值的对象，例如，先执行

std::for_each( vect[0].begin(), vect[0].end(), _1 = bind(&toupper, _1) );

然后再把这些 string 输出，你会得到

HELLO, world!

因为那一句对 "Hello" 中的每一个字母调用 toupper ，并把结果写回。

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

第一个问题：如何对一个 map 中所有的 key 或者 value 做某件事情？

当然，这还是取决于你要做的是什么。手写 for 循环当然是万能的，但是现在有了那么多的泛型算法，我们可以考虑其他的方案了（这也是众多 C++ Gurus 推荐的思维方式）如果是把所有的 value 全部 cout 出来，用 boost.lambda 配合 for_each 还是比较优雅的（虽然没有像 vector 和 list 那样的优雅）：

#include <iostream>
#include <algorithm>
#include <map>
#include <string>

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace boost::lambda;

int main()
{
  std::map<int, std::string> strs;
  strs[0] = "Hello";
  strs[1] = ", ";
  strs[2] = "world";
  strs[3] = "!";
 
  std::for_each( strs.begin(), strs.end(),
    std::cout << bind(&std::map<int, std::string>::value_type::second, _1) );
}

这样的输出如我们所料，就是 Hello, world! 。

如果想要把 key 也输出，道理是一样的，只需要这样：

  std::for_each( strs.begin(), strs.end(),
    std::cout << bind(&std::map<int, std::string>::value_type::second, _1) << '\t'
                    << bind(&std::map<int, std::string>::value_type::first, _1) << '\n'
  );

其结果是：

Hello   0
,            1
world   2
!            3

因此，对于一个 map 中的 value 的操作往往可以依法炮制，如果我们想要在其中寻找 value 为 “world" 的那一个元素，并且输出它的 key ，只需要一句话：

  std::cout <<
    std::find_if( strs.begin(), strs.end(),
      bind(&std::map<int, std::string>::value_type::second, _1) == "world" )->first;

STL 算法 find_if 接受的第三个参数是一个 prediate ，而生成这种临时的 functor 正是 lambda 的拿手好戏。上面的这句话也可以用 boost::bind 来做，只需要更改 include 和 using namespace ，代码本身无需更改。而如果你不借助于它们，你只有手写循环或者自己写一个 predicate 。

当情况变得复杂一些的时候，lambda 的用法也变得更加有趣了：

#include <iostream>
#include <algorithm>
#include <map>
#include <string>

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace boost::lambda;

class Person
{
public:
  Person(){}
  Person(const std::string& name) : name_(name){}
 
  std::string Name()
  { return name_; }
 
private:
  std::string name_;
};

int main()
{
  std::map<int, Person> persons;
  persons[123] = Person("Amy");
  persons[234] = Person("Ralph");
  persons[345] = Person("Simon");
  persons[456] = Person("Maggie");

  std::for_each( persons.begin(), persons.end(),
    std::cout << bind(&std::map<int, Person>::value_type::first, _1) << '\t'
                    << bind(&Person::Name,
                            bind(&std::map<int, Person>::value_type::second, _1)) << '\n'
  );

  std::cout << "Ralph's Id is: " <<
    std::find_if( persons.begin(), persons.end(),
      bind(&Person::Name,
        bind(&std::map<int, Person>::value_type::second, _1)) == "Ralph" )->first;
}

这里 map 的 value 元素不再是一个单纯的 string，我们要输出的是这个 value 的 Name() ，幸好 lambda 的绑定可以级联，所以我们仍然可以用 STL 算法在一个表达式之内搞定这些任务：for_each 输出 key 和 value 的 Name()，而 find_if 找到 value 的 Name() 为 "Ralph" 的那一个元素，输出是这样的：

123     Amy
234     Ralph
345     Simon
456     Maggie
Ralph's Id is: 234

如果你想要把一个容器内的所有元素累加起来，应该怎么办？

如果你想要把一个容器内的所有元素累加起来，应该怎么办？

STL 的 accumulate 可以让我们不必自己写循环：

#include <iostream>
#include <functional>
#include <numeric>
#include <vector>
#include <string>

int main()
{
  std::vector<int> vect;
  vect.push_back(1);
  vect.push_back(2);
  vect.push_back(3);
  vect.push_back(4);
 
  std::cout << "Accumulate: " <<
    std::accumulate( vect.begin(), vect.end(), 0, std::plus<int>());
}

输出：

Accumulate: 10

其中的 std::plus<int>() 可以省略，因为这将是3个参数的 accumulate 的默认行为。 注意 accumulate 算法是定义在 numeric 里面而不是 algorithm 里面的。

由于 accumulate 和 plus 都是泛型的，所以如果你要累加的不是 int 而是字符串，对程序的修改也并不大：

#include <iostream>
#include <functional>
#include <numeric>
#include <vector>
#include <string>

int main()
{
  std::vector<std::string> vect;
  vect.push_back("1");
  vect.push_back("2");
  vect.push_back("3");
  vect.push_back("4");
 
  std::cout << "Accumulate: " <<
    std::accumulate( vect.begin(), vect.end(), std::string(""));
}

输出：
Accumulate: 1234

不过，如果使用 boost.lambda ，这个问题会有一些很好看又容易理解的解法：

#include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <string>

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
//#include <boost/bind.hpp>

using namespace boost::lambda;
//using namespace boost;

int main()
{
  std::vector<std::string> vect;
  vect.push_back("1");
  vect.push_back("2");
  vect.push_back("3");
  vect.push_back("4");
 
  std::string result;
 
  std::for_each( vect.begin(), vect.end(), result += _1);
 
  std::cout << result;
}

输出：
1234

这里要借用变量 result ，在这个程序中显得多了几行，但是我们调用 accumulate 的目的也往往是把结果放到一个变量中，这样的话，使用 boost.lambda 反而会漂亮一些。

在上面的程序中，另一个丑陋的地方就是 vector 的初始化，为了把 1, 2, 3, 4 放进 vect 里面，我们居然要调用 push_back 4次！不过，使用 boost.lambda 就好得多了。

  std::vector<int> vect(10);
  int i = 0;
  std::for_each( vect.begin(), vect.end(), _1 = ++var(i) );

这里有两个地方值得注意：
1. 现在必须在 vect 的声明中指出其大小，否则 for_each 对一个空容器可是什么也不会做
2. 必须使用 ++var(i) ，而不是 ++i 。var 在这里的作用是强迫 lazy evaluation ，也就是让变量在被用到的时候在求值，如果用 ++i ，你会得到一个装有10个1的 vect ，而不是装有1-10。

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

许多问题遇到 map 都会变得复杂起来，如果想要把一个 map 中所有的 key 或者 value 累加起来，该怎么办呢？这个时候已经不能直接使用 accumulate 了，用 boost.bind 可以办到，做法是这样的：

#include <iostream>
#include <algorithm>
#include <numeric>
#include <map>
#include <string>

#include <boost/bind.hpp>

using namespace boost;

int main()
{
  std::map<int, std::string> persons;
  persons[123] = "Amy";
  persons[234] = "Ralph";
  persons[345] = "Simon";
  persons[456] = "Maggie";
 
  std::cout << std::accumulate( persons.begin(), persons.end(), 0,
    bind(std::plus<int>(), _1, bind(&std::map<int, std::string>::value_type::first, _2)) )
    << std::endl;

  std::cout << std::accumulate( persons.begin(), persons.end(), std::string(),
    bind(std::plus<std::string>(), _1, bind(&std::map<int, std::string>::value_type::second, _2)) )
    << std::endl;
}

输出：

1158
AmyRalphSimonMaggie

办是办到了，但是平心而论，的确算不上是漂亮。连续的 bind 并不比自己写的循环更让人头晕。boost.lambda 也要用到 bind ，然而可以清晰许多：

#include <iostream>
#include <algorithm>
#include <numeric>
#include <map>
#include <string>

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace boost::lambda;

int main()
{
  std::map<int, std::string> persons;
  persons[123] = "Amy";
  persons[234] = "Ralph";
  persons[345] = "Simon";
  persons[456] = "Maggie";

  int iresult = 0;
  std::string sresult;
 
  std::for_each( persons.begin(), persons.end(),
    iresult += bind(&std::map<int, std::string>::value_type::first, _1)
  );
 
  std::for_each( persons.begin(), persons.end(),
    sresult += bind(&std::map<int, std::string>::value_type::second, _1)
  );
 
  std::cout << iresult << std::endl;
  std::cout << sresult << std::endl;
}

输出和上面的一样：

1158
AmyRalphSimonMaggie

有了它的帮助，即便间接层次再增加一层，也不会有太多困难：假如你的 map 并不直接存储 string ，而是存储 Person 对象，而它们的名字要通过 Name() 方法来取得，代码只需要稍微的修改：

#include <iostream>
#include <algorithm>
#include <numeric>
#include <map>
#include <string>

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace boost::lambda;

class Person
{
public:
  Person(){}
  Person(const std::string& name) : name_(name){}
 
  std::string& Name()
  { return name_; }
 
private:
  std::string name_;
};

int main()
{
  std::map<int, Person> persons;
  persons[123] = Person("Amy");
  persons[234] = Person("Ralph");
  persons[345] = Person("Simon");
  persons[456] = Person("Maggie");

  std::string result;
 
  std::for_each( persons.begin(), persons.end(),
    result += bind(&Person::Name, bind(&std::map<int, Person>::value_type::second, _1))
  );
 
  std::cout << result;
}

输出：

AmyRalphSimonMaggie

上次提到过为容器生成数据的问题，我给出的用 boost.lambda 的方法是

上次提到过为容器生成数据的问题，我给出的用 boost.lambda 的方法是：

  std::vector<int> vect(10);
  int i = 0;
  std::for_each( vect.begin(), vect.end(), _1 = ++var(i) );

不错，这样可以生成连续的数字，也还算比较简洁，因为代码量不会随着容器的大小而变化，不过，如果要在容器内填入随机数呢？其实比上面更简单，因为 STL 的 generate 算法就是设计来做这个的：

  std::vector<int> vect(10);
  std::generate(vect.begin(), vect.end(), rand);

rand 是我们熟悉的标准 C 库函数，这样我们可以生成任意数量的随机数了，不过还是有点不好的地方：每次生成的序列都是一样的，因为 rand 生成的是伪随机数。这个容易解决，我们必须先 seed 一下：

  std::vector<int> vect(10);
  srand(time(NULL));
  std::generate(vect.begin(), vect.end(), rand);

好了，我们终于还是用了三行（其实是两行，声明 vector 总是必需的吧！），但是好歹是有了一个可用的方案。回头看看，前面的连续整数问题也可以用 generate 来做，方法不言而喻：

  std::vector<int> vect(10);
  int i = 0;
  std::generate(vect.begin(), vect.end(), ++var(i));

好处是 generate 本身更能说明这句话的用途，当然这个可能因人而异。

我知道有人一定在问：一定要两行么？一定要有一个初始变量么？答案是可以没有，但是要用到另外的算法，再加上 boost.lambda 的协助。看看下面：

  std::vector<int> vect(10);
  std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = _1 + 1);

如果你现在把 vect 输出，你会得到：

0 1 2 3 4 5 6 7 8 9

乍看起来不太好理解，我来慢慢解释。
partial_sum 的第4个参数是一个双参数的 functor ，在这里，lambda 表达式 _2 = _1 + 1 充当了这个角色，它相当于

f(x, y)  {  y  =  x  +  1;  }

而 partial_sum 呢？它把一个序列的 partial sum 送到结果序列中去，例如如果输入一个数组 v[10] ，而输出是 r[10] ，那么它的计算就是

r[0] = v[0]            
r[1] = f( r[0], r[1] )
r[2] = f( r[1], r[2] )
......
r[9] = f( r[8], r[9] )

而当我们把 partial_sum 作用于 vect 本身，结果就成了

vect[0] = vect[0]                            // vect[0] = 0
vect[1] = (vect[1] = vect[0] + 1)   // vect[1] = 1
vect[2] = (vect[2] = vect[1] + 1)   // vect[2] = 2
......
vect[9] = (vect[9] = vect[8] + 1)   // vect[9] = 9

你一定发现其中的问题所在了：首先，我们必须依赖于编译器把 vect[0] 初始化为0，其次，vect[0] = vect[0] 是不可回避的。以我当前所想到的，也只能这样了。

推广一下，如果把 _2 = _1 + 1 中的常数 1 换成另外的数字，我们就可以用一句话得到从 0 开始的等差数列，例如

  std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = _1 + 3);

得到的是

0 3 6 9 12 15 18 21 24 27

如果再发挥一点想象力，你就可以构造出更复杂的 lambda 表达式，从而得到更复杂的数组（也许这里叫数列更好吧），例如

  std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = 2 * _1 + 1);

得到的是 2 的 n 次方 - 1 数列

0 1 3 7 15 31 63 127 255 511

在 STL 算法中，adjacent_difference 和 partial_sum 是逆运算，因此，上面的事情也可以用 adjacent_difference 来做，只不过要把 lambda 表达式中的参数位置换一下，例如要得到 0, 3, 6... 的等差数列，只需要

  std::adjacent_difference(vect.begin(), vect.end(), vect.begin(), _1 = _2 + 3);

而 2 的 n 次方 - 1 数列也是同样道理

  std::adjacent_difference(vect.begin(), vect.end(), vect.begin(), _1 = 2*_2 + 1);

如果你要生成倒序的数列呢？当然，STL 算法 reverse 可以派上用场，不过也不要忘了 STL 还有 reverse_iterator 这回事，用它就无需另外调用 reverse 了：

  std::partial_sum(vect.rbegin(), vect.rend(), vect.rbegin(), _2 = 2*_1 + 1);

得到

511 255 127 63 31 15 7 3 1 0

最后还要提醒大家不要忘了一个很有用的 STL 算法： random_shuffle 。它可以把 Random access container 里面的值打乱，配合上面的数列生成，在很多场合是进行测试 （例如测试排序算法） 的好工具。在我的机器上，下面两行

  std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = 2*_1 + 1);
  std::random_shuffle(vect.begin(), vect.end());

得到打乱以后的数列：

255 1 511 3 0 31 127 7 15 63

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

有了强大的生成机制作基础，下面的实验也更加容易了。STL 的 count_if 和 find_if 都接受一个 predicate 作为比较的依据，而这个 predicate 往往非常简单，以至于为它专门写一个 functor 简直不可接受。在第一篇里面已经展示了用 boost.lambda 生成临时的无名 functor 的能力，这里再多说一点。

下面先生成 2^n - 1 的数组，然后找出其中第一个大于100的数

  std::vector<int> vect(10);
  std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = 2*_1 + 1);
 
  std::cout << *std::find_if(vect.begin(), vect.end(), _1 > 100);

输出为 127 ，如我们所料。同样道理，如果是 count_if ，则会得到大于100的数的个数

  std::cout << std::count_if(vect.begin(), vect.end(), _1 > 100);

输出是 3 。注意细节：find_if 返回一个 iterator ，所以在它之前有 * 解引用，而 count_if 直接返回一个数字，无需解引用。

与之类似的还有 STL 的 partition 算法，它根据传入的 predicate 对一个序列进行划分，predicate 得到 true 的将放在前面，其余的放在后面，返回的是那些“ 放在 后面”的元素中的第一个，换言之就是分界点。下面的代码

  std::vector<int> vect(10);
  std::partial_sum(vect.begin(), vect.end(), vect.begin(), _2 = 2*_1 + 1);
 
  std::cout << *std::partition(vect.begin(), vect.end(), _1 > 100) << std::endl;
 
  std::for_each(vect.begin(), vect.end(), std::cout << _1 << " ");

输出为

7
511 255 127 7 15 31 63 3 1 0

如果仔细观察，还可以发现上面的输出有点问题：数列中原有的顺序（0, 1, 3, 7...）不复存在，这是因为 partition 并不是一个稳定排序的算法，它不保证排序结果保有原来的顺序。如果需要稳定排序，可以使用 stable_partition 。只需要更改排序的那一句代码为

  std::cout << *std::stable_partition(vect.begin(), vect.end(), _1 > 100) << std::endl;

结果是

0
127 255 511 0 1 3 7 15 31 63

当然，如果你还记得大学里的算法理论，就知道它们在效率上是有点区别的，partition 的复杂度保证为 O(n) ，具体地说是保证不超过 n/2 次交换；而 stable_partition 在最好情况下为 O(n) ，最差情况则达到 O(n*log(n)) 。

顺便说一下，上面的几件简单的事情，用标准的 STL 算法都可以办到，只不过实在是……面目可憎：

  std::cout << *std::partition(vect.begin(), vect.end(),
    std::bind2nd(std::greater<int>(), 100)) << std::endl;

这句代码做的事情和前面的 partition 一模一样，但是孰优孰劣，大家自有公断。

总有一些时候，我们不能够借助于“生成式”的初始化方法来给容器赋值，例如我们已经有了一个数组，要把它作为初值赋给一个容器，常规的做法已经深入人心了

总有一些时候，我们不能够借助于“生成式”的初始化方法来给容器赋值，例如我们已经有了一个数组，要把它作为初值赋给一个容器，常规的做法已经深入人心了：

  int init[] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
  std::vector<int> vect(init, init + sizeof(init)/sizeof(int));

通过两个 sizeof 来得到数组的大小在 C 语言里面是很常见的，然而在 C++ 里面，这即便不能称为丑陋，也绝对称不上是好。首先其可读性不好，其次它要进行一次除法来得到一个本来在编译期间就知道的数字，最后，它并不是总能用的！例如下面的例子：

  std::string strs[] = { "Amy", "Ralph", "Simon", "Maggie" };

现在，你打算用 "sizeof " 什么来除以 "sizeof" 什么？

其实，经过了这么多 C++ GP 的磨练，我们很容易就会想到一个在编译期间得到静态数组大小的办法，模板偏特化是我们常用的武器，在这里非常好用：

template <class T>
struct ArraySize
{
    static const unsigned int value = 0;
};

template <class T, int S>
struct ArraySize<T[S]>
{
    static const unsigned int value = S;
};

就这么简单！虽然它只对付一维数组，但是扩展它是很容易的。不过，模板参数只能为类型，而我们需要传入的是一个变量。好在在计算机科学里面，加一层抽象是可以解决任何问题的，我们只要加一个模板函数，C++ 会自动帮我们做类型推导：

template <class T>
unsigned int array_size(const T&)
{
    return ArraySize<T>::value;
}

现在我们可以轻而易举的搞定那些数组了：

  int ints[] = {2, 3, 5, 7, 11, 13, 17, 19, 23};
  std::vector<int> vint(ints, ints + array_size(ints));
 
  std::string strs[] = { "Amy", "Ralph", "Simon", "Maggie" };
  std::vector<std::string> vstr(strs, strs + array_size(strs));
 
  std::for_each(vint.begin(), vint.end(), std::cout << _1 << " ");
  std::cout << std::endl;
  std::for_each(vstr.begin(), vstr.end(), std::cout << _1 << " ");

输出：

2 3 5 7 11 13 17 19 23
Amy Ralph Simon Maggie

顺便说一下，在 boost.type_traits 里面有一个类似于 ArraySize 的工具，叫做 extent ，它更加强大，可以对付多维数组，不过是否值得为了这个而把 boost.type_traits 包含到工程里面去就看读者自己抉择了。

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

容器的初始化是如此的常见，以至于 boost 提供了一个 assign 库来简化这些操作。boost.assign 大量利用了重载的逗号和括号来简化赋值操作，提供了甚至比用数组更加简洁的语法：

#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

#include <boost/assign/std/vector.hpp>
#include <boost/assign/std/list.hpp>

using namespace boost::assign;

int main()
{
  std::vector<int> vint;
  vint += 2,3,5,7,11,13,17,19,23;
 
  std::vector<std::string> vstr;
  vstr += "Amy","Ralph","Simon","Maggie";
 
  std::list<std::string> lstr;
  lstr += "Amy","Ralph","Simon","Maggie";
   
  std::for_each(vint.begin(), vint.end(), std::cout << _1 << " ");
  std::cout << std::endl;
  std::for_each(vstr.begin(), vstr.end(), std::cout << _1 << " ");
  std::cout << std::endl;
  std::for_each(lstr.begin(), lstr.end(), std::cout << _1 << " ");
}

运行这个程序，输出与前面的大致相同，但是我们注意到初始化更加简洁了，而且也不需要额外的空间来存储数组，对于各种类型，都能够以统一的方式来初始化，真是妙不可言。有趣的是 assign 的作者在文档中还特意引用了 Bjarne Stroustrup 的话作为引子：

There appear to be few practical uses of operator,().
Bjarne Stroustrup, The Design and Evolution of C++

这也许就是 C++ 最大的魅力之一：你无法预料它可以办到些什么。

下面关于 map 的例子也使用 boost.assign ，可以看到重载的括号给我们带来了多少方便。

#include <iostream>
#include <algorithm>
#include <map>
#include <string>

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

#include <boost/assign/list_inserter.hpp>
#include <boost/assign/list_of.hpp>

using namespace std;
using namespace boost::assign;
using namespace boost::lambda;

int main()
{
  map<string,int> months; 
 
  insert( months )
    ( "january",   31 )( "february", 28 )
    ( "march",     31 )( "april",    30 )
    ( "may",       31 )( "june",     30 )
    ( "july",      31 )( "august",   31 )
    ( "september", 30 )( "october",  31 )
    ( "november",  30 )( "december", 31 );
   
  map<int,string> persons = map_list_of
    (2,"Amy")(3,"Ralph")
    (5,"Simon")(7,"Maggie");
   
  for_each( months.begin(), months.end(),
    cout << bind(&map<string,int>::value_type::second, _1) << "\t"
         << bind(&map<string,int>::value_type::first, _1) << "\n"
  );
  cout << endl;
  for_each( persons.begin(), persons.end(),
    cout << bind(&map<int,string>::value_type::first, _1) << "\t"
         << bind(&map<int,string>::value_type::second, _1) << "\n"
  ); 
}

输出：

30      april
31      august
31      december
28      february
31      january
31      july
30      june
31      march
31      may
30      november
31      october
30      september

2       Amy
3       Ralph
5       Simon
7       Maggie

boost在vc2005中的编译出现codepage警告和DEPRECATED函数的解决近日下载了一个VC2005 Express Edition，用它来编译boost，发现有不少的warning C4819，说代码文件中有cp936无法表示的字符，还有就是vc2005特有的废弃的ANSI函数的错误，虽说不影响编译，但是看着时不时出现的warning总是让人心神不安，还容易掩盖其他的错误，如果是直接用cl编译，只要加上/wd4819 /D_CRT_SECURE_NO_DEPRECATE就可以不显示这两个错误，但是大家都知道boost是使用其特有的boost.build进行编译的，下面我就给出如何修改boost.build来抑制这两个错误的显示

boost.build分为v1和v2两个版本
v1：
修改$(BOOST_ROOT)/tools/build/v1/vc-8_0-tools.jam
将

 flags vc - 8_0 C ++ FLAGS :  / Zc:forScope ;
改为

 flags vc - 8_0 C ++ FLAGS :  / Zc:forScope  / wd4819  / D_CRT_SECURE_NO_DEPRECATE ;
v2：
cvs版本
修改$(BOOST_ROOT)/tools/build/v2/tools/msvc.jam
在

 #  8.0  adds some more options
 
一行的下方加上

 flags msvc.compile CFLAGS $(condition) :  / wd4819  / D_CRT_SECURE_NO_DEPRECATE ;
 
boost 1.33.1版本
将

    #  8.0  deprecates some of the options
     if   !  [ MATCH  ^ ([ 67 ]. * ) : $(version) ]
    {
        flags msvc.compile CFLAGS $(condition) /< optimization > speed :  / O2 ;
        flags msvc.compile CFLAGS $(condition) /< optimization > space :  / O1 ;
        flags msvc.link.dll MANIFEST :  " mt -manifest  "  ;
        flags msvc.link.dll OUTPUTRESOURCE :  " -outputresource: "  ;
    }
改为：

    #  8.0  deprecates some of the options
     if   !  [ MATCH  ^ ([ 67 ]. * ) : $(version) ]
    {
        flags msvc.compile CFLAGS $(condition) :  / wd4819  / D_CRT_SECURE_NO_DEPRECATE ;
        flags msvc.compile CFLAGS $(condition) /< optimization > speed :  / O2 ;
        flags msvc.compile CFLAGS $(condition) /< optimization > space :  / O1 ;
        flags msvc.link.dll MANIFEST :  " mt -manifest  "  ;
        flags msvc.link.dll OUTPUTRESOURCE :  " -outputresource: "  ;
    }