多态， 事实上，这是 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各自有序，请把它们合并成一个链表依然有序，要求用递归方法进行。

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

从 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: "  ;
    }

预处理器在编译器之前根据指令更改程序文本。编译器看到的是预处理器修改过的代码文本（称作“翻译单元（translation unit）”）。

预处理器的三大功能：

1。头文件或源文件包含；

2。宏扩展；

3。条件编译；

头文件包含：

#include <stdio.h>         //编译器首先到标准头文件库查找；

#include “myHead.h”     //编译器首先到当前目录下查找，如找不到再到标准头文件库查找；

预处理指令：

#include  #define  #undef  #if  #elif  #else  #endif  #ifdef  #ifndef  #error  #line  #pragma

宏定义：

用#define定义一个宏；用#undef删除一个宏；

宏的分类：

无参数宏（类对象宏）

例：

#define MAXLINES 500

类对象宏类似常数，因此可以用下面语句代替，并且推荐用下面语句来定义。

Const int MAXLINES = 500;

       带参数宏（类函数宏）

例：

#define abs(x)  ( (x) > 0 ? (x) : (- (x) ) )          

//参数最好用括号封装，这样在替换时不会产生歧义

类函数宏大多可以用内联函数来代替，并且推荐。

inline int abs(int x)

{

       return x > 0 ? x : (-x);

}

预定义宏：

__LINE__  __FILE__  __DATE__  __TIME__  __cplusplus

例：

// sysmac.cpp

#include <iostram>

using namespace std;

main()

{

       Cout << “__DATE__ == “ << __DATE__ << endl;

       Cout << “__TIME__ == “ << __TIME__ << endl;

       Cout << “__LINE__ == “ << __LINE__ << endl;

       Cout << “__FILE__ == “ << __FILE__ << endl;

}

//输出：

__DATE__ == Nov 28 1996

__TIME__ == 09:37:38

__LINE__ == 7

__FILE__ == sysmac.cpp

预处理运算符：

#  ##  Defined

# 字符串化；## 加标记；

具体看下面的例子：

#include <stdio.h>

#define trace(x,format)  printf(#x  “= %”  #format  “\n” , x)

#define trace2(i)  trace(x  ## i , d)

main()

{

       int i = 1;

float x = 2.0;

char *s = “three”;

trace(i,d);                     //printf( “x” “=%” “d” “\n” , x)

trace(x,f);

trace(s,s);

Int x1=1,x2=2,x3=3;

trace2(1);                     //trace(x1,d)

trace2(2);

trace2(3);

}

//输出：

i = 1

x = 2.000000

s = three

x1 = 1

x2 = 2

x3 = 3