给定一个含有n个元素的整型数组a，从中任取m个元素，求所有组合。比如下面的例子

a = 1, 2, 3, 4, 5

m = 3

输出

1 2 3, 1 2 4, 1 2 5, 1 3 4, 1 3 5, 1 4 5

2 3 4, 2 3 5, 2 4 5
3 4 5

分析

典型的排列组合问题，首选回溯法，为了简化问题，我们将a中n个元素值分别设置为1-n

关于这个命令的详细可以man看一下

[基本用法]

iconv –f encoding –t encoding inputfile

-f: –-from-code  指定原始文件编码

-t: –to-code 指定输出编码

例如我存储一个a.txt，文件采用utf-8编码保存，如果要修改为Big5格式的，可以这么写：

$: iconv –f utf-8 –t Big5 a.txt

如果希望结果存储进b.txt

$: iconv –f utf-8 –t Big5 a.txt –o b.txt

-o: –output 指定目标文件

如果不知道该怎么指定编码，可以使用

$: iconv –l

来查看所有已知的字符集

上面文件的操作如果没有方便的工具，可以使用word来查看或者建立。

2.iconv函数

与iconv command一样，更多的信息同样可以man来查看，注意这里需要man 3 iconv到另外一个manpage。

相关的函数主要有3个：

1.iconv_open

[函数原型]：

#include <iconv.h>

iconv_t iconv_open(const char* tocode, const char* fromcode);

[函数说明]

该函数分配一个编码转换的描述符，从fromcode转到tocode

tocode字符串后可以添加//TRANSLIT,//IGNORE。

函数失败则返回-1，同时设置errno

常见的errno：

EINVAL The conversion from fromcode to tocode is not supported by the implementation.

2.iconv_open

[函数原型]：

#include <iconv.h>

size_t iconv(iconv_t cd, char** inbuf, size_t *inbytesleft, char** outbuf, size_t *outbytesleft);

cd:转码描述符

*inbuf:指向源字符串

*inbytesleft：指向需要读取的长度

*outbuf:指向目标字符串

*outbytesleft: 指向可用的目标地址长度

细心的读者肯定已经发现，这里传入的全是指针，因为这里的参数并不只是起到一个传入的作用！

为了不误人子弟，关于iconv的工作流程，直接贴了manpage里的一句话：

The argument cd must be a conversion descriptor created using the function iconv_open(3).

The main case is when inbuf is not NULL and *inbuf is not NULL.  In this case, the iconv() function converts the multibyte sequence starting at *inbuf to a multi‐
byte sequence starting at *outbuf.  At most *inbytesleft bytes, starting at *inbuf, will be read.  At most *outbytesleft bytes, starting at *outbuf, will be writ‐
ten.

The  iconv() function converts one multibyte character at a time, and for each character conversion it increments *inbuf and decrements *inbytesleft by the number
of converted input bytes, it increments *outbuf and decrements *outbytesleft by the number of converted output bytes, and it updates  the  conversion  state  con‐
tained  in cd.  If the character encoding of the input is stateful, the iconv() function can also convert a sequence of input bytes to an update to the conversion
state without producing any output bytes; such input is called a shift sequence.  The conversion can stop for four reasons:

1. An invalid multibyte sequence is encountered in the input.  In this case it sets errno to EILSEQ and returns (size_t) -1.   *inbuf  is  left  pointing  to  the
beginning of the invalid multibyte sequence.

2.  The  input byte sequence has been entirely converted, that is, *inbytesleft has gone down to 0.  In this case iconv() returns the number of nonreversible con‐
versions performed during this call.

3. An incomplete multibyte sequence is encountered in the input, and the input byte sequence terminates after it.  In this  case  it  sets  errno  to  EINVAL  and
returns (size_t) -1.  *inbuf is left pointing to the beginning of the incomplete multibyte sequence.

4. The output buffer has no more room for the next converted character.  In this case it sets errno to E2BIG and returns (size_t) -1.

A different case is when inbuf is NULL or *inbuf is NULL, but outbuf is not NULL and *outbuf is not NULL.  In this case, the iconv() function attempts to set cd's
conversion state to the initial state and store a corresponding shift sequence at *outbuf.  At most *outbytesleft bytes, starting at *outbuf, will be written.  If
the  output buffer has no more room for this reset sequence, it sets errno to E2BIG and returns (size_t) -1.  Otherwise it increments *outbuf and decrements *out‐
bytesleft by the number of bytes written.

A third case is when inbuf is NULL or *inbuf is NULL, and outbuf is NULL or *outbuf is NULL.  In this case, the iconv() function sets cd's conversion state to the
initial state.

看的不是很懂也没有关系，我再贴下自己的翻译和理解：

iconv函数会从*inbuf开始，每转换一个字符，增大*inbuf,减少*inbytesleft,增大/减少的字节数即为转换的input字节数，同时增大*outbuf,减少*outbytesleft,增大/减少的字节数即为转换的output字节数。

编码的转换遇到以下四种情况会stop：

1.inbuf里碰到非法的字节：这种情况设置errno为EILSEQ，返回(size_t)-1,*inbuf指向非法字符的开始处。

2.inbuf里字节完全转换：*inbytesleft减少至0，返回不可逆的转换的字节数（这个不明白什么意思，似乎是由于在目标字符集里找不到字符的问题？）

3.inbuf不完整的字符串：设置errno为EINVAL，返回(size_t)-1,*inbuf指向不完整字符的开始处。

    比如一个字符占了4个字节，我故意只穿了前3个字节进去。

4.outbuf空间不够，此时设置errno为E2BIG，返回-1.

关于返回值还在纠结的直接看这里，自己体会下：

The  iconv()  function  returns  the  number  of characters converted in a nonreversible way during this call; reversible conversions are not counted.  In case of
error, it sets errno and returns (size_t) -1.

3.iconv_close

[函数原型]：

#include <iconv.h>

int iconv_close(iconv_t cd);

关闭转换编码的描述符，成功返回0，否则设置errno并返回-1.

说了这么多，来个例子看下，其中源代码文件保存为utf-8编码，test.txt可以在word里使用BIG5编码查看。

如果还有什么疑问，欢迎评论。

http://www.pkware.com/documents/casestudies/APPNOTE.TXT

#4.3.7 Local file header:的部分

更详细的可参考非常nb的zlib：

http://www.zlib.net/

主要的作用是读取一个zip文件，列出压缩前的文件列表。

比如：

y@y-VirtualBox:~/MyDocuments/Training$ ./a.out test.zip
page0.bmp
page1.bmp
page2.bmp
page3.bmp

代码：

有两个疑惑的地方：

1.对于所谓的signature0x01024b50,如何做到压缩后的内容肯定不会是这个值呢，这个估计要看下压缩算法才明白。

2.查找signature的方法太朴素了，应当如何改进？

3.如何在不一次读取整个文件内容得到结果？

1.plain new/delete.普通的new,定义如下：

void *operator new(std::size_t) throw(std::bad_alloc);

void operator delete(void*) throw();

注：标准C++ plain new失败后抛出标准异常std::bad_alloc而非返回NULL，因此检查返回值是否为NULL判断分配是否成功是徒劳的。

测试程序：

输出：

std::bad_alloc
2.

nothrow new/delete不抛出异常的运算符new的形式，new失败时返回NULL。

定义如下：

void *operator new(std::size_t,const std::nothrow_t&) throw();

void operator delete(void*) throw();

struct nothrow_t{};  const nothrow_t nothrow;//nothrow作为new的标志性哑元

测试程序：

输出：

alloc failure!
failure
3.

placement new/delete 主要用途是：反复使用一块较大的动态分配成功的内存来构造不同类型的对象或者它们的数组。例如可以先申请一个足够大的字符数组，然后当需要时在它上面构造不同类型的对象或数组。placement new不用担心内存分配失败，因为它根本不分配内存，它只是调用对象的构造函数。

测试程序：

输出：

ADT::ADT
ADT::~ADT

参考资料：

http://blog.sina.com.cn/s/blog_446b43c10100d7ci.html

http://www.cppblog.com/izualzhy/archive/2012/02/27/166633.html

根据格式的特点就可以判断一个字符串是否是utf8编码的。

参考了资料里的方法，做了简化。

主要是以下几个判断的准则：

1.如果所有字符都是ascii码,则判断为ascii而非utf8编码(ascii字符占1个字节，从1-127, 最高位为0)

2.当为多字节时，先判断第一个字节，从最高位开始，直到出现第一个0,位上为1的个数必须>=2&&<=6，检测剩下的字节，必须是10xx xxxx的形式。

参考资料：

http://www.cppblog.com/woaidongmao/archive/2011/08/27/154487.html

具体的信息可见 http://gcc.gnu.org/onlinedocs/gcc-3.3.6/gcc/Gcov-Intro.html#Gcov-Intro

       天主要介绍利用gcov生成的文件生成比较直观的web页面的一款工具lcov ，可以官网http://ltp.sourceforge.net/coverage/lcov.php去下载这款工具我下的是 这个版本。好了废话不多说，我们通过一个简单的例子来看看如何使用这款工具。

1.安装lcov

# tar -zxvf  lcov-1.10.tar.gz

#make install

这样就可以有两个工具 lcov  genhtml 可以直接敲命令看看帮助信息 --help 你懂得。。

2.测试cpp文件

[html] view plaincopyprint?

1. #include"stdio.h"  
3. #include"string.h"  
9. int Test(int i)  
11. {  
13.         if(i>0)  
15.         {  
17.                 printf("iu>0\n");  
19.         }  
21.         else{  
23.                 printf("i < 0\n");  
25.         }  
27.         return 0;  
29. }  
33. int main()  
35. {  
37.         Test(1);  
39.         return 0;  
41. } 

可以看到生成了一个test.gcno的文件

3.运行程序

./ok

生成了gcda文件

4.执行lcov 生成文件

lcov -d . -t ok -o coverage.info -b . -c

-d 后面带 执行程序（ok）的目录  -o 表示生成文件

自此生成网页的条件已经完全具备

5.生成网页端

genhtml -o result coverage.info

-o 路径 + 转换信息

页面信息如下：可以清楚的看到当前的代码哪一些分支没有走到。

      总结：

             代码覆盖率在一定程度上可以帮助我们很好进行单元测试，我们可以将一些测试用例进行上述检测，就可以知道测试用例是否能很好的覆盖到代码全部分支，进一步提高代码的稳定

原题在这里：

http://www2.stetson.edu/~efriedma/holiday/2011/index.html

题目：

有这样一个迷宫，从2011开始，不能回头，只能“朝前”走，走出迷宫的时候需要变成2012.

例如从2011开始，有+7,/2两种选择，选择/2后，又有+7,x3/-5三种选择。

解法：

其实就是2011为根的子树，不断的生成下一层的节点，直到节点值为2012。

dfs遍历肯定不现实的，bfs算是比较适合的方法了。不过有更快捷的办法，我使用的是最原始的bfs。

运算方式有四种，位置有三种，分别用枚举表示。

代码：

代码写的很长了，100行以内应该是没问题的，即使是使用我的这种笨方法o(╯□╰)o。为了条理清楚些，就多定义了些函数。

部分输出：

Achieve 2012!    2012
2011+7/2+7/2+7x3-5/2+7x3-5/2+7x3-5x3-5/2+7/2+7/2+7/2+7x3-5+7
Achieve 2012!    2012
2011+7/2+7/2+7x3-5/2+7x3-5/2+7-5x3+7/2+7/2+7/2+7/2x3-5x3-5+7
Achieve 2012!    2012
2011+7/2+7/2+7x3-5x3-5+7/2+7/2+7/2+7/2x3-5/2+7x3-5x3-5+7/2+7
Achieve 2012!    2012
2011+7/2+7/2+7x3-5x3-5+7/2+7/2+7/2+7/2x3-5/2+7-5x3/2+7x3-5+7
Achieve 2012!    2012
2011+7/2+7/2+7-5x3/2+7x3-5+7/2+7/2+7/2x3-5/2+7x3-5x3-5+7/2+7
Achieve 2012!    2012
2011+7/2+7/2+7-5x3/2+7x3-5+7/2+7/2+7/2x3-5/2+7-5x3/2+7x3-5+7
Achieve 2012!    2012
2011+7/2+7/2+7-5x3/2+7/2+7x3-5/2+7-5x3+7/2+7/2x3-5x3-5+7/2+7
Achieve 2012!    2012
2011+7/2+7/2+7-5x3/2+7/2+7x3-5/2+7-5x3+7/2+7/2-5x3/2+7x3-5+7
Achieve 2012!    2012
2011+7/2+7/2+7-5x3/2+7/2+7-5x3/2+7x3-5/2+7x3-5+7/2+7/2x3-5+7

\n： newline 向下移动一行，并不移动左右。

Linux中\n表示回车+换行；

Windows中\r\n表示回车+换行。

Mac中\r表示回车+换行。

历史：

回车”（Carriage Return）和“换行”（Line Feed）这两个概念的来历和区别。
在计算机还没有出现之 前，有一种叫做电传打字机（Teletype Model 33，Linux/Unix下的tty概念也来自于此）的玩意，每秒钟可以打10个字符。但是它有一个问题，就是打完一行换行的时候，要用去0.2秒，正 好可以打两个字符。要是在这0.2秒里面，又有新的字符传过来，那么这个字符将丢失。
于是，研制人员想了个办法解决这个问题，就是在每行后面加两个表示结束的字符。一个叫做“回车(return)”，告诉打字机把打印头定位在左边界；另一个叫做“换行(newline)”，告诉打字机把纸向下移一行。这就是“换行”和“回车”的来历，从它们的英语名字上也可以看出一二。

编译的结果：

test.cpp: In function ‘int main()’:
test.cpp:28:11: error: no matching function for call to ‘B::f()’
test.cpp:28:11: note: candidate is:
test.cpp:19:22: note: virtual void B::f(int)
test.cpp:19:22: note:   candidate expects 1 argument, 0 provided

是virtual引起的么，修改为非虚函数后，编译还是报错。

在《高质量c++编程指南》里提到了：

8.2.2 令人迷惑的隐藏规则
    本来仅仅区别重载与覆盖并不算困难，但是C++的隐藏规则使问题复杂性陡然增加。这里“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。

示例程序8-2-2（a）中：
（1）函数Derived::f(float)覆盖了Base::f(float)。
（2）函数Derived::g(int)隐藏了Base::g(float)，而不是重载。
（3）函数Derived::h(float)隐藏了Base::h(float)，而不是覆盖。

据作者考察，很多C++程序员没有意识到有“隐藏”这回事。由于认识不够深刻，“隐藏”的发生可谓神出鬼没，常常产生令人迷惑的结果。

示例8-2-2（b）中，bp和dp指向同一地址，按理说运行结果应该是相同的，可事实并非这样。

8.2.3 摆脱隐藏
    隐藏规则引起了不少麻烦。示例8-2-3程序中，语句pd->f(10)的本意是想调用函数Base::f(int)，但是Base::f(int)不幸被Derived::f(char *)隐藏了。由于数字10不能被隐式地转化为字符串，所以在编译时出错。

参考：

《高质量C++/C编程指南》

考虑执行这行代码时会发生什么：

很明显 BuyTransaction 的构造函数会被调用，但是首先，Transaction 的构造函数必须先被调用，派生类对象中的基类部分先于派生类部分被构造。Transaction 的构造函数的最后一行调用虚函数 logTransaction，但是结果会让你大吃一惊，被调用的 logTransaction 版本是在 Transaction 中的那个，而不是 BuyTransaction 中的——即使被创建的对象类型是 BuyTransaction。基类构造期间，虚函数从来不会向下匹配（go down）到派生类。取而代之的是，那个对象的行为就好像它的类型是基类。非正式地讲，基类构造期间，虚函数禁止。 这个表面上看起来匪夷所思的行为存在一个很好的理由。因为基类的构造函数在派生类构造函数之前执行，当基类构造函数运行时，派生类数据成员还没有被初始化。如果基类构造期间调用的虚函数向下匹配（go down）到派生类，派生类的函数理所当然会涉及到本地数据成员，但是那些数据成员还没有被初始化。这就会为未定义行为和悔之晚矣的调试噩梦开了一张通行证。调用涉及到一个对象还没有被初始化的部分自然是危险的，所以 C++ 告诉你此路不通。
　　在实际上还有比这更多的更深层次的原理。在派生类对象的基类构造期间，对象的类型是那个基类的。不仅虚函数会解析到基类，而且语言中用到运行时类型信息（runtime type information）的配件（例如，dynamic_cast和 typeid），也会将对象视为基类类型。在我们的例子中，当 Transaction 构造函数运行初始化 BuyTransaction 对象的基类部分时，对象的类型是 Transaction。C++ 的每一个配件将以如下眼光来看待它，并对它产生这样的感觉：对象的 BuyTransaction 特有的部分还没有被初始化，所以安全的对待它们的方法就是视若无睹。在派生类构造函数运行之前，一个对象不会成为一个派生类对象。
　　同样的原因也适用于析构过程。一旦派生类析构函数运行，这个对象的派生类数据成员就被视为未定义的值，所以 C++ 就将它们视为不再存在。在进入基类析构函数时，对象就成为一个基类对象，C++ 的所有配件——虚函数，dynamic_casts 等——都如此看待它。
　　在上面的示例代码中，Transaction 的构造函数直接调用了虚函数，对本 Item 的规则的违例是显而易见的。这一违例是如此显见，以致一些编译器会给出警告。（其它的则不会）甚至除了这样的警告之外，这一问题几乎肯定会在运行之前暴露出来，因为 logTransaction 函数在 Transaction 中是一个纯虚函数。除非它被定义（看似不可能，但确实可能），否则程序将无法连接：连接程序无法找到 Transaction::logTransaction 的必需的实现。
　　在构造函数和析构函数中调用虚函数的问题并不总是如此容易被察觉。如果 Transaction 有多个构造函数，每一个都必须完成一些相同的工作，好的软件工程为避免代码重复，会将共用的初始化代码，包括对 logTransaction 的调用，放入一个私有的非虚的初始化函数，叫做 init：

这个代码在概念上和早先那个版本相同，但是它更阴险，因为它很具代表性地会躲过编译器和连接程序的抱怨。在这种情况下，因为 logTransaction 在 Transaction 中是纯虚函数，大多数运行时系统在纯虚函数被调用时，程序会异常中止（典型的结果就是给出一条信息）。然而，如果 logTransaction 是一个“常规的”虚函数（也就是说，非纯的虚函数），而且在 Transaction 中有其实现，那个版本被调用，程序会继续一路小跑，让你想象不出为什么派生类对象创建的时候会调用 logTransaction 的错误版本。避免这个问题的唯一办法就是确保在你的构造函数和析构函数中，决不在你创建或销毁的对象上调用虚函数，构造函数和析构函数所调用的函数也要服从同样的约束。
　　但是，如何保证在任何时间 Transaction 层次结构中的对象被创建时，都能调用 logTransaction 的正确版本呢？显然，在 Transaction 的构造函数中在这个对象上调用虚函数的做法是错误的。
　　有不同的方法来解决这个问题。其中之一是将 Transaction 中的 logTransaction 转变为一个非虚函数，这就需要派生类的构造函数将必要的日志信息传递给 Transaction 的构造函数。那个函数就可以安全地调用非虚的 logTransaction。如下：

换句话说，因为在基类的构造过程中你不能使用虚函数，就改为由派生类传递必要的构造信息给基类的构造函数作为补偿。 在此例中，注意 BuyTransaction 中那个（私有的）static 函数 createLogString 的使用。使用一个辅助函数创建一个值传递给基类的构造函数，通常比通过在成员初始化列表给基类它所需要的东西更加便利（也更加具有可读性）。将那个函数做成 static，就不会有偶然涉及到一个初生的 BuyTransaction 对象的仍未初始化的数据成员的危险。这很重要，因为实际上那些数据成员在一个未定义状态，这就是为什么在基类构造和析构期间虚函数不能首先匹配到派生类的原因。
　　Things to Remember
　　·在构造和析构期间不要调用虚函数，因为这样的调用不会匹配到当前执行的构造函数或析构函数所属的类的更深的派生层次。

问题起源于这样一个小题目：

L5，定了了ptr值为100，ptr是一个数组的指针，数组大小为5.

L6，(*ptr)为int数组的首地址，即100，(*ptr)[1]=ptr+sizeof(int)*1

L7, *ptr[1],ptr地址为100，指向了一个大小为5的数组，20的字节，根据数组+1的定义，ptr+1就意味着要从ptr的位置前进20个字节，即ptr + sizeof(5*sizeof(int))*1

原文地址：

http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/kmpen.htm

以下为原文内容：

Idea

After a shift of the pattern, the naive algorithm has forgotten all information about previously matched symbols. So it is possible that it re-compares a text symbol with different pattern symbols again and again. This leads to its worst case complexity of Θ(nm) (n: length of the text, m: length of the pattern).

The algorithm of Knuth, Morris and Pratt [KMP 77] makes use of the information gained by previous symbol comparisons. It never re-compares a text symbol that has matched a pattern symbol. As a result, the complexity of the searching phase of the Knuth-Morris-Pratt algorithm is in O(n).

However, a preprocessing of the pattern is necessary in order to analyze its structure. The preprocessing phase has a complexity ofO(m). Since mn, the overall complexity of the Knuth-Morris-Pratt algorithm is in O(n).

Basic definitions

Definition:  Let A be an alphabet and  x = x₀ ... x_k-1, k    a string of length k over A.

A prefix of x is a substring u with

u  =  x₀ ... x_b-1   where  b {0, ..., k}

i.e. x starts with u.

A suffix of x is a substring u with

u  =  x_k-b ... x_k-1   where  b {0, ..., k}

i.e. x ends with u.

A prefix u of x or a suffix u of x is called a proper prefix or suffix, respectively, if ux, i.e. if its length b is less than k.

A border of x is a substring r with

r  =  x₀ ... x_b-1  and  r  =  x_k-b ... x_k-1   where  b {0, ..., k-1}

A border of x is a substring that is both proper prefix and proper suffix of x. We call its length b the width of the border.

Example:  Let x = abacab. The proper prefixes of x are

ε, a, ab, aba, abac, abaca

The proper suffixes of x are

ε, b, ab, cab, acab, bacab

The borders of x are

ε, ab

The border ε has width 0, the border ab has width 2.

The empty string ε is always a border of x, for all x A⁺. The empty string ε itself has no border.

The following example illustrates how the shift distance in the Knuth-Morris-Pratt algorithm is determined using the notion of the border of a string.

Example:

The symbols at positions 0, ..., 4 have matched. Comparison c-d at position 5 yields a mismatch. The pattern can be shifted by 3 positions, and comparisons are resumed at position 5.

The shift distance is determined by the widest border of the matching prefix of p. In this example, the matching prefix is abcab, its length is j = 5. Its widest border is ab of width b = 2. The shift distance is j – b  =  5 – 2  =  3.

In the preprocessing phase, the width of the widest border of each prefix of the pattern is determined. Then in the search phase, the shift distance can be computed according to the prefix that has matched.

Preprocessing

Theorem:  Let r, s be borders of a string x, where |r| < |s|. Then r is a border of s.

Proof:  Figure 1 shows a string x with borders r and s. Since r is a prefix of x, it is also a proper prefix of s, because it is shorter thans. But r is also a suffix of x and, therefore, proper suffix of s. Thus r is a border of s.

Figure 1:  Borders r, s of a string x

If s is the widest border of x, the next-widest border r of x is obtained as the widest border of s etc.

Definition:  Let x be a string and a A a symbol. A border r of x can be extended by a, if ra is a border of xa.

Figure 2:  Extension of a border

Figure 2 shows that a border r of width j of x can be extended by a, if x_j = a.

In the preprocessing phase an array b of length m+1 is computed. Each entry b[i] contains the width of the widest border of the prefix of length i of the pattern (i = 0, ..., m). Since the prefix ε of length i = 0 has no border, we set b[0] = -1.

Figure 3:  Prefix of length i of the pattern with border of width b[i]

Provided that the values b[0], ..., b[i] are already known, the value of b[i+1] is computed by checking if a border of the prefix p₀ ... p_i-1can be extended by symbol p_i. This is the case if p_b[i] = p_i (Figure 3). The borders to be examined are obtained in decreasing order from the values b[i], b[b[i]] etc.

The preprocessing algorithm comprises a loop with a variable j assuming these values. A border of width j can be extended by p_i, ifp_j = p_i. If not, the next-widest border is examined by setting j = b[j]. The loop terminates at the latest if no border can be extended (j = -1).

After increasing j by the statement j++ in each case j is the width of the widest border of p₀ ... p_i. This value is written to b[i+1] (to b[i] after increasing i by the statement i++).

Preprocessing algorithm

void kmpPreprocess()
{
    int i=0, j=-1;
    b[i]=j;
    while (i<m)
    {
        while (j>=0 && p[i]!=p[j]) j=b[j];
        i++; j++;
        b[i]=j;
    }
}

Example:  For pattern p = ababaa the widths of the borders in array b have the following values. For instance we have b[5] = 3, since the prefix ababa of length 5 has a border of width 3.

Searching algorithm

Conceptually, the above preprocessing algorithm could be applied to the string pt instead of p. If borders up to a width of m are computed only, then a border of width m of some prefix x of pt corresponds to a match of the pattern in t (provided that the border is not self-overlapping) (Figure 4).

Figure 4:  Border of length m of a prefix x of pt

This explains the similarity between the preprocessing algorithm and the following searching algorithm.

Searching algorithm

void kmpSearch()
{
    int i=0, j=0;
    while (i<n)
    {
        while (j>=0 && t[i]!=p[j]) j=b[j];
        i++; j++;
        if (j==m)
        {
            report(i-j);
            j=b[j];
        }
    }
}

When in the inner while loop a mismatch at position j occurs, the widest border of the matching prefix of length j of the pattern is considered (Figure 5). Resuming comparisons at position b[j], the width of the border, yields a shift of the pattern such that the border matches. If again a mismatch occurs, the next-widest border is considered, and so on, until there is no border left (j = -1) or the next symbol matches. Then we have a new matching prefix of the pattern and continue with the outer while loop.

Figure 5:  Shift of the pattern when a mismatch at position j occurs

If all m symbols of the pattern have matched the corresponding text window (j = m), a function report is called for reporting the match at position i-j. Afterwards, the pattern is shifted as far as its widest border allows.

In the following example the comparisons performed by the searching algorithm are shown, where matches are drawn in green and mismatches in red.

Example:

Analysis

The inner while loop of the preprocessing algorithm decreases the value of j by at least 1, since b[j] < j. The loop terminates at the latest when j = -1, therefore it can decrease the value of j at most as often as it has been increased previously by j++. Since j++ is executed in the outer loop exactly m times, the overall number of executions of the inner while loop is limited to m. The preprocessing algorithm therefore requires O(m) steps.

From similar arguments it follows that the searching algorithm requires O(n) steps. The above example illustrates this: the comparisons (green and red symbols) form "stairs". The whole staircase is at most as wide as it is high, therefore at most 2ncomparisons are performed.

Since mn the overall complexity of the Knuth-Morris-Pratt algorithm is in O(n).

References

[KMP 77]
D.E. Knuth, J.H. Morris, V.R. Pratt: Fast Pattern Matching in Strings. SIAM Journal of Computing 6, 2, 323-350 (1977)

[1]
http://www-igm.univ-mlv.fr/~lecroq/string/

[2]
http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/stringmatchingclasses/KmpStringMatcher.java   Knuth-Morris-Pratt algorithm as a Java class source file

看以下代码：

问题就在于，去掉std::sort那一行，以上代码将运行更长的时间。在我的机器上未去掉std::sort耗时8.99s，去掉后耗时24.78s。编译器使用的是gcc4.4.3。事实上，以上代码跟编译器没有关系，甚至跟语言没有关系。那这是为什么呢？

这跟处理这个数组的逻辑有非常大的关系。如以上代码所示，这个循环里有个条件判断。条件判断被编译成二进制代码后，就是一个跳转指令，类似：

具体为什么会不同，这涉及到计算机CPU执行指令时的行为。

CPU的流水线指令执行

想象现在有一堆指令等待CPU去执行，那么CPU是如何执行的呢？具体的细节可以找一本计算机组成原理的书来看。CPU执行一堆指令时，并不是单纯地一条一条取出来执行，而是按照一种流水线的方式，在CPU真正执行一条指令前，这条指令就像工厂里流水线生产的产品一样，已经被经过一些处理。简单来说，一条指令可能经过这些过程：取指(Fetch)、解码(Decode)、执行(Execute)、放回(Write-back)。

假设现在有指令序列ABCDEFG。当CPU正在执行(execute)指令A时，CPU的其他处理单元（CPU是由若干部件构成的）其实已经预先处理到了指令A后面的指令，例如B可能已经被解码，C已经被取指。这就是流水线执行，这可以保证CPU高效地执行指令。

Branch Prediction

如上所说，CPU在执行一堆顺序执行的指令时，因为对于执行指令的部件来说，其基本不需要等待，因为诸如取指、解码这些过程早就被做了。但是，当CPU面临非顺序执行的指令序列时，例如之前提到的跳转指令，情况会怎样呢？

取指、解码这些CPU单元并不知道程序流程会跳转，只有当CPU执行到跳转指令本身时，才知道该不该跳转。所以，取指解码这些单元就会继续取跳转指令之后的指令。当CPU执行到跳转指令时，如果真的发生了跳转，那么之前的预处理（取指、解码）就白做了。这个时候，CPU得从跳转目标处临时取指、解码，然后才开始执行，这意味着：CPU停了若干个时钟周期！

这其实是个问题，如果CPU的设计放任这个问题，那么其速度就很难提升起来。为此，人们发明了一种技术，称为branch prediction，也就是分支预测。分支预测的作用，就是预测某个跳转指令是否会跳转。而CPU就根据自己的预测到目标地址取指令。这样，即可从一定程度提高运行速度。当然，分支预测在实现上有很多方法。

简单的预测可以直接使用之前的实际执行结果。例如某个跳转指令某一次产生了跳转，那么下一次执行该指令时，CPU就直接从跳转目标地址处取指，而不是该跳转指令的下一条指令。

答案

了解了以上信息后，文章开头提出的问题就可以解释了。这个代码中有一个循环，这个循环里有一个条件判断。每一次CPU执行这个条件判断时，CPU都可能跳转到循环开始处的指令，即不执行if后的指令。使用分支预测技术，当处理已经排序的数组时，在若干次data[c]>=128都不成立时（或第一次不成立时，取决于分支预测的实现），CPU预测这个分支是始终会跳转到循环开始的指令时，这个时候CPU将保持有效的执行，不需要重新等待到新的地址取指；同样，当data[c]>=128条件成立若干次后，CPU也可以预测这个分支是不必跳转的，那么这个时候CPU也可以保持高效执行。

相反，如果是无序的数组，CPU的分支预测在很大程度上都无法预测成功，基本就是50%的预测成功概率，这将消耗大量的时间，因为CPU很多时间都会等待取指单元重新取指。

本文完。最后感叹下stackoverflow上这个帖子里那个老外回答问题的专业性，我要是楼主早就感动得涕泪横飞了。感谢每一个传播知识的人。

参考资料

1. http://blog.sina.com.cn/s/blog_6c673e570100zfmo.html
2. http://www.cnblogs.com/dongliqian/archive/2012/04/05/2433847.html
3. http://en.wikipedia.org/wiki/Branch_predictor

原文地址： http://codemacro.com/2012/08/29/branch-predictor/
written by Kevin Lynx  posted at http://codemacro.com

求组合数：求n个数中K个数的组合，假设函数原型为  intcombination （int n,int k ）,其中  n 的范围为  1 ……n,

例如：combination（5 ，3 ） 要求输出：543、542 、541 、531 、532 、521 、432 、431 、421 、321 如果输出时有用到数组，其空间需要在开始动态分配好，结束时释放。

第一想法是5!/3!/2!o(╯□╰)o

写程序的话其实很简单了，我用的递归，递归注意下结束条件就可以了：

好吧，写这篇日志其实是为了测试下这个插件好用不好用。。。

收集了一些关于字符/宽字符的一些资料，在此与大家一起分享。

win2下wchar占2个字节   linux下wchar占4个字节

wchar_t的高位字节应该存储在char数组的低位字节。

在 C 语言中， char 类型永远都是一个字节， 双字节字符类型是 wchar_t；但它不是内置类型， 定义在 stddef.h.

给 wchar_t 类型的字符或字符数组（也就是字符串）赋值要冠以 L；

格式化输出（如 printf） wchar_t 类型的字符串， 要用 %S（而非 %s）。（我更多的是看到用ls输出）；

而且 要注意一点，printf和wprintf不能混用，否则不会打印。如：

setlocale(LC_ALL,"zh_CN.utf8");
printf("1 print chinese by wprintf test: \n");
wchar_t *wstr = L"中文";
wprintf(L"%ls",wstr);

上面先使用了printf，又使用了wprintf，所以后面的wprintf无法正常输出，只要把上面printf换成wprintf或是注释掉就可以了。

mbs: multi byte string, 用char作为存储类型, 一个字符可能对应1个或者多个char, 不能直接确定字符边界. charset不确定. 过去的程序都是采用mbs的.

wcs: wide character string, 用wchar_t作为存储类型, 一个字符对于一个wchar_t. 使用unicode编码, charset与OS相关, 在windows平台中为UTF16(UCS-2), 在大多数unix平台中为UTF32(UCS-4).

国际化的程序都应该在内部使用wcs, 在输入输出时做mbs与wcs的转换.

#include <stdlib.h>
#include <stdio.h>
#include <locale.h> 


int main()
{
    FILE* fp ;
    setlocale(LC_ALL,"");             //要先设置语言环境
    wchar_t wchar[5] = L"相等相等";    //定义一个宽字节的变量，初始为"相等"
    fp = fopen("1.txt", "w+");        //打开文件称奥做
    fwprintf(fp, L"%ls\n", wchar);    //输出到文件.此处一定要为%ls，不能用%s
    fclose(fp);                       //关闭文件
    wchar_t wc2[5];                   //定义第二个宽字节变量
    
    int i = 0;
    //wc开始的有很多宽字节的操作。都和str相对应。
    wcscpy(wc2, wchar);                //复制。
    int n = wcscmp(wc2, wchar);        //比较
    if (n == 0)
    {
        wprintf(L"相等\n");            
    }
    else
    {
        wprintf(L"不相等\n");
    }

    char str[10];                    //定义char字符。
    n = wcstombs(str, wc2, 9);       //宽字节转换为muiltychar
    printf("1---: %s\n", str);       //输出结果

    for (i = 0; i < 5; ++i)
    {
        wc2[i] = L'1' + i;
    }
    wc2[4] = 0;

    n = wcstombs(str, wc2, 9);        //宽字节转换为muiltychar
    printf("2---:%s\n", str);         //输出结果
    
    return 0;
}

mbs与wcs的转换函数:

#include <locale.h>
setlocale(LC_ALL, "");

wcstombs(char * to,wchar_t * from,size_t _maxCount);
mbstowcs(wchar_t * to,char * from,size_t _maxCount);

wcstombs/mbstowcs是实现转换的一对函数. 这两个c的库函数其实内部也就是对刚刚windows的api和接下来我们要说的iconv的封装。使用时要注意，如果涉及到中文，要先setlocale，当设置好正确的locale，函数内部才能找到正确的字符集进行转换。

wcs的charset是固定不可变的, 但是mbs的charset是可变的, 可能是ASCII, 可能是gb2312, 也可能是big5. wcstombs/mbstowcs是根据locale环境设置来决定mbs采用的charset的, 在程序中可以用setlocale来设定locale, 例如 setlocale(LC_ALL, "chinese")

程序启动时, locale设定为 LC_ALL="C", 用 setlocale(LC_ALL, "") 就可以设置成操作系统的locale设定.

Locale决定了当前程序运行的本地化设置方式, 但是在程序中可能需要作其他charset的转换, 例如程序本身语言设定为简体中文, 需要做big5与unicode的转换, 或者是其他两种charset的mbstombs转换, 这时wcstombs/mbstowcs就不能胜任了.

/*
linux 下 wchar_t和char的相互转化和测试
win32下wchar_t占2个字节，linux下wchar_t占4个字节。wchar_t的高字节应该存放在char数组的低字节。
Linux下面的没有命名为 WideCharToMultiByte() 和 MultiByteToWideChar() 函数，WideCharToMultiByte，MultiByteToWideChar是windows下的函数，
在linux下也有类似的两个函数：
mbstowcs()
wcstombs() 
值得注意的是:
size_t mbstowcs(wchar_t *wcstr,const char *mbstr,size_t count);
这个函数的第三个参数count，大小一定要是mbstr长度的2倍，否则出来的中文也会是乱码。

wcstombs和mbstowcs使用
#include <locale.h>
setlocale(LC_ALL, "");
wcstombs(char * to,wchar_t * from,size_t _maxCount);
mbstowcs(wchar_t * to,char * from,size_t _maxCount);

还有呢，转码还可以使iconv函数族，包含以下三个函数（其具体实例可以见demo_iconv.c和code_convert.c）：
iconv_t iconv_open(const char *tocode, const char *fromcode);
size_t iconv(iconv_t cd,char **inbuf,size_t *inbytesleft,char **outbuf,size_t *outbytesleft);
int iconv_close(iconv_t cd);
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <locale.h>


size_t get_wchar_size(const char *str)
{
   size_t len = strlen(str);
   size_t size=0;
   size_t i;
   for(i=0; i < len; i++)
   {
      if( str[size] >= 0 && str[size] <= 127 ) //不是全角字符
      size+=sizeof(wchar_t);
      else //是全角字符，是中文
      {
        size+=sizeof(wchar_t);
        i+=2;
      }
   }
  return size;
}

char *w2c(const wchar_t *pw)
{
   if(!pw)
   return NULL;

   size_t size= wcslen(pw)*sizeof(wchar_t);
   char *pc;
   if(!(pc = (char*)malloc(size)))
   {
     printf("malloc fail");
     return NULL;
   }
   wcstombs(pc,pw,size);
   return pc;

}

wchar_t *c2w(const char *pc)
{
   if(!pc)
   return NULL;

   size_t size_of_ch = strlen(pc)*sizeof(char);
   size_t size_of_wc = get_wchar_size(pc);
   wchar_t *pw;
   if(!(pw = (wchar_t*)malloc(size_of_wc)))
   {
      printf("malloc fail");
      return NULL;
   }
   mbstowcs(pw,pc,size_of_wc);
   return pw;

}

int main(void)
{
   setlocale(LC_ALL,"zh_CN.utf8");
   printf("1 print chinese by wprintf test: \n");
   wchar_t *wstr = L"中文";
   //wprintf(L"%ls",wstr); //此处不要使用wprintf，因为上面已经使用了printf，而他们使用的是不同的流，不能混用
   printf("%ls\n",wstr); //ls

   printf("2 print chinese by printf test: \n");
   char *str = "汉字";
   printf("%s\n\n\n",str); //s

   printf("3 char and wchar_t size of system test: \n");
   printf("%s%d\n","the size of wchar_t is : ",sizeof(wchar_t)); //4
   printf("%s%d\n\n\n","the size of char is : ",sizeof(char));   //1

   char *pc;
   wchar_t *pw = L"中文是abc一门语言abc";
   char *tmp = "中文是abc一门语言abc";
   printf("%s%s\n","input test wchar_t* ",tmp);
   pc = w2c(pw);
   printf("4 print char test after w2c (wchar to char):\n");
   printf("%s\n",pc);


   wchar_t *cw1 = c2w(pc);   //char to wchar
   char *wc1 = w2c(cw1);   //wchar to char
   printf("5 print char test after w2c c2w and w2c:\n");
   printf("%s\n\n\n",wc1);

   char *pmc = "abc中文abc";
   wchar_t *pmw;
   printf("%s%s\n","input test char* ",pmc);
   pmw = c2w(pmc);
   char *pmc1 = w2c(pmw);
   printf("6 print char test after c2w and w2c:\n");
   printf("%s\n",pmc1);

   printf("%ls\n",wstr);
   //cout<<wstr<<endl;
   return 0;

} 

在unix平台中可以使用iconv来做这个转换(iconv lib也有windows版本), 在windows平台可以用MultiByteToWideChar/WideCharToMultiByte 函数.

iconv库的使用

利用iconv函数族进行编码转换（如GB2312转换为UTF-8）

iconv函数族的头文件是iconv.h,使用前需包含之。

#include <iconv.h>

iconv函数族有三个函数,原型如下:

(1) iconv_t iconv_open(const char *tocode, const char *fromcode);

此函数说明将要进行哪两种编码的转换,tocode是目标编码,fromcode是原编码,该函数返回一个转换句柄,供以下两个函数使用。

(2)size_t iconv(iconv_t cd,char **inbuf,size_t *inbytesleft,char **outbuf,size_t *outbytesleft);

此函数从inbuf中读取字符,转换后输出到outbuf中,inbytesleft用以记录还未转换的字符数,outbytesleft用以记录输出缓冲的剩余空间。参数cd必须是由iconv_open函数创建的转换描述符。

/*
    iconv库的使用
    GB2312字符串转换为UTF-8的字符串

    利用iconv函数族进行编码转换
    iconv函数族的头文件是iconv.h,使用前需包含之。
    #include <iconv.h>
    iconv函数族有三个函数,原型如下:
    (1) iconv_t iconv_open(const char *tocode, const char *fromcode);
    此函数说明将要进行哪两种编码的转换,tocode是目标编码,fromcode是原编码,该函数返回一个
    转换句柄,供以下两个函数使用。
    (2) size_t iconv(iconv_t cd,char **inbuf,size_t *inbytesleft,char **outbuf,size_t *outbytesleft);
    此函数从inbuf中读取字符,转换后输出到outbuf中,inbytesleft用以记录还未转换的字符数,outbytesleft用以记录输出缓冲的剩余空间。
    (3) int iconv_close(iconv_t cd);
    此函数用于关闭转换句柄,释放资源。
*/
#include <stdio.h>
#include <stdlib.h>
#include <iconv.h>
#include <string.h>

int main(void)
{
    unsigned char *src = "魅影追击和歌姬"; /* 需转换的字串 */
    unsigned char dst[256] = {0}; /* 转换后的内容 */
    unsigned char buf[1024] = {0}; /* 格式化转换后的字串 */
    size_t src_len = strlen(src);
    size_t dst_len = sizeof(dst);
    unsigned char *in = src;
    unsigned char *out = dst;
   
    iconv_t cd;
    int i; 
    int j; 
   
    cd = iconv_open("UTF-8", "GB2312"); /* 将GB2312字符集转换为UTF-8字符集 */
    if ((iconv_t)-1 == cd)
    {
        return -1;
    }

    printf("src: %s\n", src);
    iconv(cd, &in, &src_len, &out, &dst_len); /* 执行转换 */

    /* 以下将转换后的内容格式化为: %XX%XX...形式的字串 */
    printf("dst: ");
    j = 0; 
    for (i = 0; i < strlen(dst); i++)
    {
        printf("%.2X ", dst[i]);
        buf[j++] = '%';
        snprintf(buf + j, 3, "%.2X", dst[i]);
        j += 2;
    }
    printf("\n");
    printf("buf: %s\n", buf);
   
    iconv_close(cd); /* 执行清理 */
    return 0;
}

大部分情形是inbuf 不为NULL，*inbuf也不为NULL。这种情况下，iconv函数将以*inbuf起始的多字节序列转换到以*outbuf起始的多字节序列。从*inbuf开始读取,最多*inbytesleft字节，转换后，从*outbuf开始写入,最多*outbytesleft字节。iconv函数一次转换一个多字节字符，每次字符转换，*inbuf增加已转换的字节数，*inbytesleft相应地减少已转换的字节数；对应地，*outbuf和*outbytesleft作相应的修改，同时修改cd的转换状态。

以下四种情况不能完成转换：

1．输入中含无效的多字节序列。此时，它将errno设置为EILSEQ并返回(size_t)(-1)。*inbuf指向无效序列的最左端。

2．输入的字节序列已经全部被转换过，也就是*inbytesleft减少至0。此时，iconv返回本次调用中完成转换的数目（可逆的转换不计入）。

3．输入中以不完整多字节序列作结尾。此时，它将errno设置为EINVAL并返回(size_t)(-1)。*inbuf指向不完整多字节序列的最左端。

4．输出缓存区没有足够空间来存储下一个字符。此时，它将errno设置为E2BIG并返回(size_t)(-1)。

另一种情形是inbuf 为NULL或*inbuf为NULL，但*outbuf 不为NULL，*outbuf也不为NULL。这种情况下，iconv函数试图将cd的转换状态设置为初始状态并store a corresponding shift sequence at *outbuf。从*outbuf开始，最多写入*outbytesleft字节。如果输出缓存区没有足够空间来存储这个重置后的序列，他将errno设置为E2BIG并返回(size_t)(-1)。反之，*outbuf增加写入的字节数和*outbytesleft减少写入的字节数。

第三种情形是inbuf 为NULL或*inbuf为NULL，*outbuf 为NULL或*outbuf为NULL。这种情况下，iconv函数试图将cd的转换状态设置为初始状态。

返回值

iconv函数返回本次调用中转换的字符数，可逆的转换不计入。出错时，它将修改errno并返回(size_t)(-1)。

错误

除了其它错误以外，出现以下错误：

E2BIG

*outbuf没有足够的空间。

EILSEQ

输入含无效的多字节序列。

EINVAL

输入含不完整多字节序列。

(3) int iconv_close(iconv_t cd);

此函数用于关闭转换句柄,释放资源。

这个库使用很简单，使用举例：

int gbk2utf8(char *dst, int outlen,char *src,int inlen)
{
     static iconv_t  its_conv;
     char *p1;
     its_conv = iconv_open("UTF-8","GBK");
     const char*  p = src;
     p1 = dst;
     iconv(its_conv, &p, &inlen, &p1, &outlen);
     //printf("%s\n",out);
     iconv_close(its_conv);
     return 0;
}

网上一个人写的支持windows和linux的wchar_t与UTF-8编码之间的转换和UTF-16和wchar_t之间的转换代码

#ifdef WINDOWS  
 #include <windows.h>   
 #include <stdio.h>  
 #include <ctype.h>  
#else  
 #include <iconv.h>  
 #include <wctype.h>  
 #include <wchar.h>  
 #include <errno.h>  
#endif  
     
 //wchar_t转成UTF-8  
int FW2UTF8Convert( const wchar_t* a_szSrc, int a_nSrcSize, char* a_szDest, int a_nDestSize )  
{  
     #ifdef WINDOWS  
         return WideCharToMultiByte( CP_UTF8, 0, a_szSrc, -1, a_szDest, a_nDestSize, NULL, NULL );  
     #else  
         size_t result;  
         iconv_t env;  
         env = iconv_open("UTF-8","WCHAR_T");  
         if (env==(iconv_t)-1)  
         {  
              printf("iconv_open WCHAR_T->UTF8 error%s %d\n",strerror(errno),errno) ;  
              return -1;  
         }  
         result = iconv(env,(char**)&a_szSrc,(size_t*)&a_nSrcSize,(char**)&a_szDest,(size_t*)&a_nDestSize);  
         if (result==(size_t)-1)  
         {  
              printf("iconv WCHAR_T->UTF8 error %d\n",errno) ;  
              return -1;  
         }  
         iconv_close(env);  
         return (int)result;  
     #endif  
}  
  
 //UTF-8转成wchar_t  
int FUTF82WConvert( const char* a_szSrc, wchar_t* a_szDest, int a_nDestSize )  
{  
     #ifdef WINDOWS  
         return MultiByteToWideChar( CP_UTF8, 0, a_szSrc, -1, a_szDest, a_nDestSize );  
     #else  
         size_t result;  
         iconv_t env;  
         int size = strlen(a_szSrc)+1 ;  
         env = iconv_open("WCHAR_T","UTF-8");  
         if (env==(iconv_t)-1)  
         {  
              printf("iconv_open UTF8->WCHAR_T error %d\n",errno) ;  
              return -1;  
         }  
         result = iconv(env,(char**)&a_szSrc,(size_t*)&size,(char**)&a_szDest,(size_t*)&a_nDestSize);  
         if (result==(size_t)-1)  
         {  
              printf("iconv UTF8->WCHAR_T error %d\n",errno) ;  
              return -1;  
         }  
         iconv_close(env);  
         return (int)result;  
     #endif  
}
   
 //wchar_t转成utf16  
int FW2UConvert( const wchar_t* a_szSrc, int  a_nSize,char* a_szDest, int a_nDestSize )  
{  
     #ifdef WINDOWS  
         memcpy_s((wchar_t*)a_szDest,a_nDestSize,a_szSrc,a_nSize);  
         return a_nSize ;  
     #else  
         size_t result;  
         iconv_t env;  
         env = iconv_open("UCS-2-INTERNAL","UCS-4-INTERNAL");  
         if (env==(iconv_t)-1)  
         {  
              printf("iconv_open WCHAR_T->UTF16 error%s %d\n", strerror(errno),errno);  
              return -1;  
         }  
         result = iconv(env,(char**)&a_szSrc,(size_t*)&a_nSize,(char**)&a_szDest,(size_t*)&a_nDestSize);  
         if (result==(size_t)-1)  
         {  
              printf("iconv WCHAR_T->UTF16 error %s %d\n", strerror(errno), errno);  
              return -1;  
         }  
         iconv_close(env);  
         return (int)result;  
     #endif  
}  
  
  
 //utf16转成wchar_t  
int FU2WConvert( const  char* a_szSrc, int a_nSize, wchar_t* a_szDest, int a_nDestSize )  
{  
     #ifdef WINDOWS  
         memcpy_s(a_szDest,a_nDestSize,(const wchar_t*)a_szSrc,a_nSize);  
         return a_nSize ;  
     #else  
         size_t result;  
         iconv_t env;  
         env = iconv_open("UCS-4-INTERNAL","UCS-2-INTERNAL");  
         if (env==(iconv_t)-1)  
         {  
              printf("iconv_open error %d\n",errno) ;  
              return -1;  
         }  
         result = iconv(env,(char**)&a_szSrc,(size_t*)&a_nSize,(char**)&a_szDest,(size_t*)&a_nDestSize);  
         if (result==(size_t)-1)  
         {  
              printf("UTF16 -> WCHAR_T conv error %d\n",errno) ;  
              return -1;  
         }  
         iconv_close(env);  
         return (int)result;  
     #endif  
}

网上不错的资源：

C/C++ 编程中多国语言处理

http://www.ibm.com/developerworks/cn/linux/l-cn-ccppglb/index.html?ca=drs-

彻底解密C++宽字符：1、从char到wchar_t

http://blog.csdn.net/wallaceli1981/archive/2010/07/16/5740615.aspx

彻底解密C++宽字符：2、Unicode和UTF

http://blog.csdn.net/wallaceli1981/archive/2010/07/16/5740616.aspx

彻底解密C++宽字符：3、利用C运行时库函数转换

http://blog.csdn.net/wallaceli1981/archive/2010/07/16/5740618.aspx

彻底解密C++宽字符：4、利用codecvt和use_facet转换

http://blog.csdn.net/wallaceli1981/archive/2010/07/16/5740620.aspx

彻底解密C++宽字符：5、利用fstream转换

http://blog.csdn.net/wallaceli1981/archive/2010/07/16/5740621.aspx

彻底解密C++宽字符：6、国际化策略

http://blog.csdn.net/wallaceli1981/archive/2010/07/16/5740622.aspx

C 源文件内的中文(1)

http://hi.baidu.com/cyclone/blog/item/e48c76099b002ca22eddd4c3.html

C 源文件内的中文(2)

http://hi.baidu.com/cyclone/blog/item/25b262d973e9d72111df9bcf.html

UTF-8 and Unicode FAQ for Unix/Linux

http://blog.csdn.net/lovekatherine/archive/2007/08/30/1765903.aspx

pad

park

panda

pan

apply

apple

append

app

application

需要统计以p为前缀的单词个数，好的，最直观的办法，我遍历所有的字符串，记数，ok，作业完成了！

A: 完成的很好！那现在我想要pa开始的~

Me: 嗯~好的，遍历，记数，ok~

A:我要app前缀的个数~

Me: 嗯?~好吧。。

A:appl的，pan的，前缀个数~

Me: ….

是不是很无奈，这个时候字典树就派上用场了。当然首先要明确的是，我们的目标是以空间换时间。

字典树，从根节点开始，每个节点可能的child数是26（如果只有英文小写字母的话），当然是随着词汇添加而完善这棵树的。

运行结果：

y@y-VirtualBox:/mnt/mydocuments/Training$ ./Trie
input the words for trie
pad
park
panda
pan
apply
apple
append
app
application

search what u want?:
p
p: 4
a
a: 5
pa
pa: 4
pan
pan: 2
par
par: 1
app
app: 5
appl
appl: 3
appe
appe: 1

int *p1 = new int(1);

int *p2 = p1;

…//一段足以让我们忘记了p2,p1关系的代码

delete p1;

*p2 = xxx;//出错，p1已经delete了。

这种情况经常让人苦恼，智能指针可以很好的处理这点。

原理其实很简单：

对于每次指针的复制(类似于int *p2 = p1)，构造等操作,智能指针内部都有一个引用计数来记录，除非引用计数为0，否则不会删除指向的对象。

我的简单的实现：

/*
 * =====================================================================================
 *       Filename:  SmartPointer.cpp
 *    Description:  implement of smart pointer
 *
 *        Version:  1.0
 *        Created:  08/18/2012 04:36:36 PM
 *
 *         Author:  zhy (), izualzhy@163.com
 * =====================================================================================
 */
#include <iostream>
using namespace std;

template <class T>
class MySmartPointer;

/**
 * @brief 引用计数类
 */
template <typename T>
class MyRefPtr
{
    friend class MySmartPointer<T>;
    MyRefPtr(T* p)
        : ptr(p)
        , counter(1)
    {}

    ~MyRefPtr()
    {
        if (counter<=0)
            delete ptr;
    }

    T* ptr;
    int counter;
};

template <typename T>
class MySmartPointer
{
public:
    MySmartPointer(T* p)
        : refPtr(new MyRefPtr<T>(p))
    {
        cout << "Count: " << refPtr->counter << endl;
    }

    MySmartPointer(const MySmartPointer<T>& SPtr)
        : refPtr(SPtr.refPtr)
    {
        ++refPtr->counter;
        cout << "Count: " << refPtr->counter << endl;
    }

    MySmartPointer& operator=(const MySmartPointer<T>& rhs)
    {
        +rhs.refPtr->counter;
        if (--refPtr->counter == 0)
            delete refPtr;
        refPtr = rhs.refPtr;
        cout << "Count: " << refPtr->counter << endl;
        return *this;
    }

    ~MySmartPointer()
    {
        cout << "Count: " << refPtr->counter << endl;
        if (--refPtr->counter == 0)
            delete refPtr;
    }

    T& operator*()
    {
        return *(refPtr->ptr);
    }

    T* operator->()
    {
        return refPtr->ptr;
    }

private:
    MyRefPtr<T>* refPtr;
};

class Test
{
public:
    Test() { c='x';cout << "Test::Test" << endl;}
    ~Test() {cout << "Test::~Test" << endl;}
    char c;
};

int main()
{
    Test* test = new Test;
    cout << test->c << endl;
    MySmartPointer<Test> sptr1(test);
    cout << sptr1->c << endl;
    sptr1->c = 'a';
    MySmartPointer<Test> sptr2(sptr1);
    cout << sptr2->c << endl;
    {
        MySmartPointer<Test> sptr3 = sptr2;
        cout << sptr3->c << endl;
    }
    cout << test->c << endl;

    return 0;
}

还觉得有问题的地方：

Test* test = new Test;

{

MySmartPointer<Test> sptr1(test);
}

看来还是有空找个详细的源码看下才行。

看个例子：

#include <stdio.h>

void __init()
{
    printf("before main\n");
}

void __exit()
{
    printf("after main\n");
}

void __init() __attribute__ ((constructor));
void __exit() __attribute__ ((destructor));

int main()
{
    printf("in main\n");

    return 0;
}

输出：

y@y-VirtualBox:/mnt/Documents/Training$ gcc -o test test.c
y@y-VirtualBox:/mnt/Documents/Training$ ./test
before main
in main
after main

稍微详细点的例子以及更多的属性在参考资料里多一些。但一直没有用到过，似乎并不是很实用的样子。

参考资料：

http://blog.csdn.net/starstarstone/article/details/7490612

sscanf用于从字符串中提取数据（整形，字符串等等）。

支持类似于正则的表达式，但却没有正则表达式强大。

很久不碰，一直只是用”%s”,”%d”,对于”[^a-z]/%[abc]”这种复杂的format却很久不使用，感觉都快遗忘了.

转换的一些规则：

sscanf() - 从一个字符串中读进与指定格式相符的数据.
　　函数原型:
　　int sscanf( string str, string fmt, mixed var1, mixed var2 ... );
　　int scanf( const char *format [,argument]... );
　　说明：
　　sscanf与scanf类似，都是用于输入的，只是后者以屏幕(stdin)为输入源，前者以固定字符串为输入源。
　　其中的format可以是一个或多个 {%[*] [width] [{h | l | I64 | L}]type | ' ' | '\t' | '\n' | 非%符号}
　　注：
　　1、 * 亦可用于格式中, (即 %*d 和 %*s) 加了星号 (*) 表示跳过此数据不读入. (也就是不把此数据读入参数中)
　　2、{a|b|c}表示a,b,c中选一，[d],表示可以有d也可以没有d。
　　3、width表示读取宽度。
　　4、{h | l | I64 | L}:参数的size,通常h表示单字节size，I表示2字节 size,L表示4字节size(double例外),l64表示8字节size。
　　5、type :这就很多了，就是%s,%d之类。
　　6、特别的：%*[width] [{h | l | I64 | L}]type 表示满足该条件的被过滤掉，不会向目标参数中写入值
　　支持集合操作：
　　%[a-z] 表示匹配a到z中任意字符，贪婪性(尽可能多的匹配)
　　%[aB'] 匹配a、B、'中一员，贪婪性
　　%[^a] 匹配非a的任意字符，贪婪性

看个例子：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char ch[100] = {0};
    sscanf("123456abcdeABCDEF", "%[1-9a-z]", ch);
    printf("%s\n",ch);

    memset(ch, 0, 100);
    sscanf("123456abcdefABCDEF", "%[^A-Z]", ch);
    printf("%s\n",ch);

    memset(ch, 0, 100);
    sscanf("hello, world", "%*s%s", ch);
    printf("%s\n",ch);

    int a,b,c;
    sscanf("2006:03:18", "%d:%d:%d",&a,&b,&c);
    printf("%d %d %d\n",a,b,c);

    char ch2[100] = {0};
    memset(ch, 0, 100);
    sscanf("iios/12DDWDFF@123", "%*[^/]/%[^@]@%s", ch,ch2);//%[]类似于一个type field
    printf("%s|%s\n", ch, ch2);

    return 0;
}

我的理解是%[],%s,%d等等就是一个type field，如果没有加*，则表示匹配的内容要存入一个buffer里面。

输出：

y@y-VirtualBox:/mnt/Documents/Training$ ./test
123456abcde
123456abcdef
world
2006 3 18
12DDWDFF|123

函数原型：

long int strtol ( const char * str, char ** endptr, int base );

unsigned long int strtoul ( const char * str, char ** endptr, int base );

double strtod ( const char * str, char ** endptr );

这几个函数从str指向的字符开始转化，忽略掉前面的空格，遇到错误无法转换的字符则返回，如果endptr不为空，则将该字符存储在endptr里。

对前两个函数，base则表示其进制。

想到之前的一篇笔记：http://www.cppblog.com/izualzhy/archive/2012/07/09/182456.html

需要将”0xE4”转到E4(1个字节)

可以简单的这么写了：

    char str[] = "E4";
    int a;
    a = strtol(str,NULL,16);

看个详细的例子：

/*
 * =====================================================================================
 *       Filename:  strtodata.c
 *    Description:  string to long/unsigned long/double
 *
 *        Version:  1.0
 *        Created:  08/16/2012 07:30:17 PM
 *
 *         Author:  zhy (), izualzhy@163.com
 * =====================================================================================
 */

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char numbers[] = "2001 60c0c0 -1101110100110100100000 0x6fffff";
    char *pEnd;
    long int li1,li2,li3,li4;
    li1 = strtol(numbers, &pEnd, 10);
    li2 = strtol(pEnd, &pEnd, 16);
    li3 = strtol(pEnd, &pEnd, 2);
    li4 = strtol(pEnd, NULL, 0);
    printf("The decimal equivalents are: %ld, %ld, %ld, %ld.\n",li1,li2,li3,li4);

    char digits[] = "365.24   29.53 -1.23456";    
    double d1,d2,d3;
    d1 = strtod(digits, &pEnd);
    printf("%c\n", *pEnd);
    d2 = strtod(pEnd, &pEnd);
    d3 = strtod(pEnd, NULL);
    printf("The moon completes %f/%f orbits per Earth yes.%f\n",d1,d2,d3);

    return 0;
}

运行结果：

The decimal equivalents are: 2001, 6340800, -3624224, 7340031.
 
The moon completes 365.240000/29.530000 orbits per Earth yes.-1.234560

参考资料：

http://www.cplusplus.com/reference/clibrary/cstdlib/strtoul/

http://blog.csdn.net/feihu521a/article/details/7648625

不过本着转化别人程序的想法，我还是根据自己的需求实现了下。

当然如原文所讲，最重要的还是源文件，即一张汉字对应拼音的一个列表。

可以从这里下载：

http://www.kuaipan.cn/file/id_63303578810318861.html

感谢原作者：Koichi Yasuoka yasuoka@kanji.zinbun.kyoto-u.ac.jp

基本功能和源程序相同，不过我保留了声调。

想着如果是中英文混合不知道该怎么处理？

贴下我的程序：

/*
 * =====================================================================================
 *       Filename:  HanZi2PinYin.cpp
 *    Description:  汉字转化为相应的拼音，汉字取得首字母的功能
 *
 *        Version:  1.0
 *        Created:  08/08/2012 07:39:56 PM
 *
 *         Author:  zhy (), izualzhy@163.com
 * =====================================================================================
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

typedef vector<string> PinyinList;
typedef vector<char> FirstLetterList;

class CHanZi2PinYin
{
public:
    CHanZi2PinYin();
    ~CHanZi2PinYin();
    /**
     * @brief HanZi2PinYin 处理单个的unicode字符
     *
     * @param wch unicode字符
     * @param pinyinList 存储可能的拼音（多音字）
     * @param firstLetterList 存储可能的首字母
     *
     * @return 返回是否成功处理
     */
    bool HanZi2PinYin(const wchar_t wch, PinyinList& pinyinList, FirstLetterList& firstLetterList);
    /**
     * @brief HanZi2PinYin 处理unicode字符串
     * 逐个计算字符串内每个字符，每次计算下一个字符时，将现有的结果逐个加上下一个字符的所有结果
     *
     * @param wstr 字符串指针
     * @param len 字符串长度
     * @param pinyinList 存储可能的拼音串，不同字符之间以空格分开
     * @param firstLetterList 存储可能的首字母串
     *
     * @return 返回是否成功处理
     */
    bool HanZi2PinYin(const wchar_t* wstr, const int len, PinyinList& pinyinList, PinyinList& firstLetterList);

private:
    bool Init();
    void UnInit();

private:
    unsigned int mHanZiStartUnicode;//汉字开始unicode，与文件对应
    unsigned int mHanZiEndUnicode;//汉字结束unicode，与文件对应
    const string mUnicode2PinyinSourceFile;//文件位置
    FILE* mpFile;//文件指针
    unsigned int mBasePos;//表示汉字开始unicode的文件位置
};

CHanZi2PinYin::CHanZi2PinYin()
    : mUnicode2PinyinSourceFile("./Uni2Pinyin")
    , mHanZiStartUnicode(0x4E00)
    , mHanZiEndUnicode(0x9FA5)
    , mpFile(NULL)
    , mBasePos(0)
{
    Init();
}

CHanZi2PinYin::~CHanZi2PinYin()
{
    UnInit();
}

bool CHanZi2PinYin::Init()
{
    const unsigned int maxstrlen = 64;
    char strline[maxstrlen] = {0};
    int nPos = 0;

    if (mpFile)
    {
        UnInit();
    }

    mpFile = fopen(mUnicode2PinyinSourceFile.c_str(), "r");
    if (mpFile == NULL)
    {
        return false;
    }

    bool findStartUnicode = false;
    nPos = ftell(mpFile);
    //找到mBasePos的正确位置
    while (fgets(strline, maxstrlen, mpFile))
    {
        if (strtoul(strline, NULL, 16) == mHanZiStartUnicode)
        {
            mBasePos = nPos;
            findStartUnicode = true;
            break;
        }
        nPos = ftell(mpFile);
    }

    return findStartUnicode;
}

void CHanZi2PinYin::UnInit()
{
    if (mpFile)
        fclose(mpFile);
    mBasePos = 0;
}


bool CHanZi2PinYin::HanZi2PinYin(const wchar_t wch, PinyinList& pinyinList, FirstLetterList& firstLetterList)
{
    //对非汉字的情况暂时不处理
    if (wch<mHanZiStartUnicode || wch>mHanZiEndUnicode)
        return false;

    //文件定位
    fseek(mpFile, mBasePos, SEEK_SET);

    char strline[64] = {0};
    unsigned int lineCounts = wch - mHanZiStartUnicode;
    //找到要查找的字符那一行
    for ( int i=0; i<=lineCounts; ++i)
        fgets(strline, 64, mpFile);

    if (strtoul(strline, NULL, 16) != wch)
    {
        return false;
    }

    int pinYinStartIndex = 5;
    for ( int i=5; i<strlen(strline); ++i)
    {
        if (strline[i] == 0x09 || strline[i] == 0x0a)
        {
            /*与源程序不同，保留了声调，因此并不去掉重复的*/
            pinyinList.push_back(string(strline+pinYinStartIndex, i-pinYinStartIndex));
            /*去掉首字母的重复*/
            if (std::find(firstLetterList.begin(), firstLetterList.end(), strline[pinYinStartIndex]) == firstLetterList.end())
            {
                firstLetterList.push_back(strline[pinYinStartIndex]);
            }
            pinYinStartIndex = i+1;
        }
    }

    return true;
}

bool CHanZi2PinYin::HanZi2PinYin(const wchar_t* wstr, const int len, PinyinList& _pinyinList, PinyinList& _firstLetterList)
{
    if ((wstr==NULL)  && (len<=0))
    {
        return false;
    }

    vector<string> pinyinStrList;//存储可能的拼音结果，每查找完成一个字符更新
    vector<string> firstLetterStrList;//存储可能的首字母结果，没查找完成一个字符更新
    vector<string> pinyinStrListStore = pinyinStrList;//临时变量，用于记录查找该字符之前的pinyinStrList结果
    vector<string> firstLetterStrListStore = firstLetterStrList;//临时变量，用于记录查找该字符之前的firstLetterStrList结果
    
    for ( int i=0; i<len; ++i)
    {
        PinyinList pinyinList;//存储本次对单个字符的拼音查找结果
        FirstLetterList firstLetterList;//存储本次对单个字符的首字母查找结果

        HanZi2PinYin(wstr[i], pinyinList, firstLetterList);
        //如果是第一个字符，赋值后返回
        if (i==0)
        {
            for ( unsigned int j=0; j<pinyinList.size(); ++j)
                pinyinStrList.push_back(pinyinList[j]);
            for ( unsigned int j=0; j<firstLetterList.size(); ++j)
                firstLetterStrList.push_back(string(1, firstLetterList[j]));
            continue;
        }

        /*记录之前的结果，并将结果清除，以便写入   */
        pinyinStrListStore = pinyinStrList;
        firstLetterStrListStore = firstLetterStrList;
        pinyinStrList.clear();
        firstLetterStrList.clear();
        
        unsigned int pinyinStrListSize = pinyinStrListStore.size();
        unsigned int firstLetterStrListSize = firstLetterStrListStore.size();

        /*更新拼音结果列表,对每个已经上次存储的字符串，加上本次所有可能的拼音结果   */
        for ( unsigned int k=0; k<pinyinStrListSize; ++k)
        {
            string pinyinStore = pinyinStrListStore[k];
            for ( unsigned int j=0; j<pinyinList.size(); ++j)
                pinyinStrList.push_back(pinyinStore+" "+pinyinList[j]);
        }
        /*更新首字母结果列表,对每个已经上次存储的字符串，加上本次所有可能的首字母结果   */
        for ( unsigned int k=0; k<firstLetterStrListSize; ++k)
        {
            string firstletterStore = firstLetterStrListStore[k];
            for ( unsigned int j=0; j<firstLetterList.size(); ++j)
                firstLetterStrList.push_back(firstletterStore+string(1, firstLetterList[j]));
        }
    }
    _pinyinList = pinyinStrList;
    _firstLetterList = firstLetterStrList;

    return true;

}

int main()
{
    CHanZi2PinYin hanzi2pinyin;
    PinyinList pylist;
    FirstLetterList fllist;

    wchar_t wstr = L'色';
    hanzi2pinyin.HanZi2PinYin(wstr, pylist, fllist);
    for ( unsigned int i=0; i<pylist.size(); ++i)
    {
        printf("%s\n", pylist[i].c_str());
    }
    for ( unsigned int i=0; i<fllist.size(); ++i)
    {
        printf("%c\n", fllist[i]);
    }

    wchar_t wstr2[] = L"银行行长色即是空";
    PinyinList pylist2;
    PinyinList fllist2;
    hanzi2pinyin.HanZi2PinYin(/*(wchar_t*)*/(wstr2), wcslen(wstr2), pylist2, fllist2);
    for ( int i=0; i<pylist2.size(); ++i)
        printf("%s\n", pylist2[i].c_str());
    for ( int i=0; i<fllist2.size(); ++i)
        printf("%s\n", fllist2[i].c_str());

    return 0;
}

_INTSIZEOF(n)定义为：

#define _INTSIZEOF(n)   ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) ) 

举个例子说明，一般机器上int大小为4，即sizeof(int) = 4

~(sizeof(int) - 1)使得最后两位变为0，而其他位全为1，也就是任何一个值与之&操作，都会为4的倍数。

而

sizeof(n) + sizeof(int) - 1的作用：

a). 如果sizeof(n)是4的倍数，则没有影响,因为加上的sizeof(int) - 1只是使最后两位变为1，在&操作时会忽略掉。

b). 如果不是，不妨设：

sizeof(n) = 4*q + r;//4<r<0

我们实际上是需要的q+1,而不是q，加上sizeof(int) - 1就达到目的了。

如果还有理论控觉得太笼统，这里有一个再合适不过的解释：

对于两个正整数 x, n 总存在整数 q, r 使得
x = nq + r, 其中  0<= r <n                  //最小非负剩余
q, r 是唯一确定的。q = [x/n], r = x - n[x/n]. 这个是带余除法的一个简单形式。在 c 语言中， q, r 容易计算出来： q = x/n, r = x % n.
所谓把 x 按 n 对齐指的是：若 r=0, 取 qn, 若 r>0, 取 (q+1)n. 这也相当于把 x 表示为：
x = nq + r', 其中 -n < r' <=0                //最大非正剩余  
nq 是我们所求。关键是如何用 c 语言计算它。由于我们能处理标准的带余除法，所以可以把这个式子转换成一个标准的带余除法，然后加以处理：
x+n = qn + (n+r')，其中 0<n+r'<=n            //最大正剩余
x+n-1 = qn + (n+r'-1), 其中 0<= n+r'-1 <n    //最小非负剩余
所以 qn = [(x+n-1)/n]n. 用 c 语言计算就是：
((x+n-1)/n)*n
若 n 是 2 的方幂, 比如 2^m，则除为右移 m 位，乘为左移 m 位。所以把 x+n-1 的最低 m 个二进制位清 0就可以了。得到：
(x+n-1) & (~(n-1))

来自：http://bbs.chinaunix.net/forum.php?mod=viewthread&tid=814501

这里http://www.cppblog.com/izualzhy/archive/2012/08/07/186592.html介绍了va_xxx的使用方法。

这篇文章具体介绍实现，网上参考资料很多，这里只做整理.

函数实现，实际上为宏：

typedef char *   va_list;   // x86平台下va_list的定义

#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) )           //第一个可选参数地址
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) //下一个参数地址
#define va_end(ap)    ( ap = (va_list)0 )                            // 将指针置为无效

_INTSIZEOF实现:

#define _INTSIZEOF(n) ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) ) 

它求出变量占用内存空间的大小，是va的实现的基础

实例讲解：

下表是针对函数int TestFunc(int n1, int n2, int n3, …)
参数传递时的内存堆栈情况。（C编译器默认的参数传递方式是__cdecl。）
对该函数的调用为int result = TestFunc(a, b, c, d. e); 其中e为结束标志。

从上图中可以很清楚地看出va_xxx宏如此编写的原因。
1． va_start。为了得到第一个可选参数的地址，我们有三种办法可以做到：
A) = &n3 + _INTSIZEOF(n3)
// 最后一个固定参数的地址 + 该参数占用内存的大小
B) = &n2 + _INTSIZEOF(n3) + _INTSIZEOF(n2)
// 中间某个固定参数的地址 + 该参数之后所有固定参数占用的内存大小之和
C) = &n1 + _INTSIZEOF(n3) + _INTSIZEOF(n2) + _INTSIZEOF(n1)
// 第一个固定参数的地址 + 所有固定参数占用的内存大小之和
从编译器实现角度来看，方法B)，方法C)为了求出地址，编译器还需知道有多少个固定参数，以及它们的大小，没有把问题分解到最简单，所以不是很聪明的途 径，不予采纳；相对来说，方法A)中运算的两个值则完全可以确定。va_start()正是采用A)方法，接受最后一个固定参数。调用va_start ()的结果总是使指针指向下一个参数的地址，并把它作为第一个可选参数。在含多个固定参数的函数中，调用va_start()时，如果不是用最后一个固定 参数，对于编译器来说，可选参数的个数已经增加，将给程序带来一些意想不到的错误。(当然如果你认为自己对指针已经知根知底，游刃有余，那么，怎么用就随 你，你甚至可以用它完成一些很优秀（高效）的代码，但是，这样会大大降低代码的可读性。)
注意：宏va_start是对参数的地址进行操作的，要求参数地址必须是有效的。一些地址无效的类型不能当作固定参数类型。比如：寄存器类型，它的地址不是有效的内存地址值；数组和函数也不允许，他们的长度是个问题。因此，这些类型时不能作为va函数的参数的。
2． va_arg身兼二职：返回当前参数，并使参数指针指向下一个参数。
初看va_arg宏定义很别扭，如果把它拆成两个语句，可以很清楚地看出它完成的两个职责。

#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) //下一个参数地址
// 将( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )拆成：
/* 指针ap指向下一个参数的地址 */
1． ap += _INTSIZEOF(t)；         // 当前，ap已经指向下一个参数了
/* ap减去当前参数的大小得到当前参数的地址，再强制类型转换后返回它的值 */
2． return *(t *)( ap - _INTSIZEOF(t)) 

回想到printf/scanf系列函数的%d %s之类的格式化指令，我们不难理解这些它们的用途了- 明示参数强制转换的类型。
(注：printf/scanf没有使用va_xxx来实现，但原理是一致的。)
3．va_end很简单，仅仅是把指针作废而已。
#define va_end(ap) (ap = (va_list)0) // x86平台

备注：

网上找到的资料重点都在上面了.

这里牵扯到一个函数参数入栈的顺序，首先明确的是栈是由高地址往低地址增长的，因此从上图可以猜到参数是从右往左进栈的，举个例子：

#include <stdio.h>
#include <stdarg.h>

void foo(int a, int b)
{
    printf("%x, %x\n", &a, &b);
}
int f1()
{
    printf("f1\n");
    return 1;
}
int f2()
{
    printf("f2\n");
    return 1;
}

int main()
{
    foo(f1(),f2());

    return 0;
}

输出：

f2
f1
bfec6c20, bfec6c24
也就是说函数参数进栈顺序从右往左，而第一个参数总是最低的地址，也就保证了可以直接取到第一个参数。

这个的使用还是非常简单的，还是先以man的一个例子说明：

#include <stdio.h>
#include <stdarg.h>

void foo(char *fmt, ...)
{
    va_list ap;
    int d;
    char c, *s;

    va_start(ap, fmt);//...之前第一个参数

    while (*fmt)
        switch (*fmt++) {
            case 's'://string
                s = va_arg(ap, char *);
                printf("string %s\n", s);
                break;
            case 'd'://int
                d = va_arg(ap, int);
                printf("int %d\n", d);
                break;
            case 'c':
                /* need a cast here since va_arg only takes fully promoted types  *///注释是照抄的，发现去掉(char)强传后没有影响，为什么？
                c = (char)va_arg(ap, int);
                printf("char %c\n", c);
                break;
        }

    va_end(ap);
}

int main()
{
    foo("sdccds", "Hello", 1, 'w', 'w', 2, "World!");

    return 0;
}

输出：

y@y-VirtualBox:~/Training$ ./test
string Hello
int 1
char w
char w
int 2
string World!
函数原型：

#include <stdarg.h>

void va_start(va_list ap, last);
type va_arg(va_list ap, type);
void va_end(va_list ap);
void va_copy(va_list dest, va_list src);

注解：

va_list:类型，ap即argument pointer

va_start:初始化ap，第二个变量必须是…之前的变量名

va_arg:在使用va_start(last, ap)初始化之后，第一次调用va_arg，它会返回last之后的变长参数表中的第一个参数，并修改ap指向下一个参数；接下来每调用一次va_arg都会返回返回一个参数，有将ap向前移动一步。va_arg除了需要ap这个参数指针之外，还需要一个数据类型type，用来决定一步应该迈多大。

va_end:与va_start对应

va_copy是用来复制va_list的，没有用到，在此就不乱讲了，免得弄错，有懂的读者可以告诉我~~

注意：

在使用过程中必须设定变长参数表解析的结束条件，可变参数并没有想象的那么智能，不能实现所有参数的类型和数目都自动判断。因此，使用时，多数会通过数值或者条件让程序知道参数的数目。例如，上面例子中的while (*fmt)就是结束条件，下面再举一个以数值边界作为条件的例子。

#include <stdio.h>
#include <malloc.h>
#include <string.h>

int main()
{
    wchar_t c = 'A';
    wchar_t a[] = L"Hello!";
    printf("%d\n", sizeof(c));
    printf("%d\n", sizeof(a));

    return 0;
}

结果：

y@y-VirtualBox:~/Training$ ./test
4
28
谁能告诉我是怎么回事？

代码是相同的：

#include <stdio.h>
#include <malloc.h>
#include <string.h>

int main()
{
    printf("%d\n", strlen("һ"));

    return 0;
}

在vim下分别输入

: set fileencoding=utf-8

or

: set fileencoding=cp936

会得到不一样的结果。

就是由于编码方式不同引起的，如果直接用gdb查看下也应该很明显了。