今天的上午的笔试题。。
从北京出发到上海的火车需要11.5个小时，从上海到北京需要12.5个小时。上海和北京2个地方，每个小时都会向对方发一辆列车。那你坐在从北京到上海的车上，能够看见多少列迎面从上海到北京的火车呢？
当时就傻了，不知道这个题目的思考点在哪儿，没想就填了11…………蠢的不得活。。。。
一在路上就想到这道题要考什么东西。。。。这道题考的东西其实很简单，当你坐上从北京到上海的列车时，路上已经存在了很多辆从上海到北京的列车，所以这些已经发出的列车都能看见。
假设从0点从北京出发，那么已经从上海发出的列车（记为a）一共有12辆。这十二辆车我们在路上都能看见。此时，从上海在0点也发了一辆车至北京。 当北京的车到上海时，时间是11：30，1点到十一点这11个小时，上海又发了11辆车。这十一辆车也能被看见。
因此，总共能看到12+1+11 = 24辆车。

xx，海笔都没让我笔。。 可能是开放性题目答得太差了。 去霸王笔的时候，被hr无情的否决了~！

严蔚敏的书 看的不是太明白，转一个

AVL-Tree，又称高度平衡树（High-Balanced Tree），是一种自平衡二叉查找树（Self-Balancing Binary Search Tree），最初由 G.M. Adelson-Velsky 和 E.M. Landis 于1962年表，并因此得名。这里不打算做细致的概念性介绍，直接分析数据结构的原理与实现。
本文内容假设读者对二叉树（Binary Tree）这种数据结构有所了解，知道树的高度（Height）等概念，并且对二叉查找树（Binary Search Tree）在搜索、插入、删除中的优点和不足已有所认识。

AVL Tree的原理实际上只有一条原则：任何一个节点的左右两个子树的高度差不大于1。对于一般的二叉查找树来说，除非输入数据受到严格控制，否则插入操作很容易产生不平衡。为解决插入过程中的不平衡，AVL Tree通过旋转（Rotations）操作来完成树的自动平衡工作。如何确定一个节点的平衡性呢？AVL Tree需要一个平衡因子（Balance Factor）来记录节点的平衡性，用以标志一个节点是处于平衡状态、左子树更高或者右子树更高。当一个节点处于平衡、左子树比右子树高1或者右子树比左子树高1这三种情况之一时，这个节点被认为处于稳定状态，不需要调整。

【约定】

• 节点（Node）：用A、B、C、D、E等字母来表示；
• 节点包括：左子树（Left Child）、右子树（Right Child）、平衡因子（Balance Factor）、数据（Data），共四个部分；
• [Node].l、[Node].r 分别表示节点 [Node] 的左子树、右子树；
• ≮、⊥、≯ 分别表示稳定状态中的 左子树高1、平衡、右子树高1；
• ≤、≥ 表示不稳定状态，即左边过高、右边过高；
• h([Node]) 表示 [Node] 节点的高度；
• b([Node]) 表示 [Node] 节点的平衡性；
• ＝ 表示两个 值/表达式 相等。

由于BST在左右两个方向上是对称的，所以后面的讨论都只针对一种情况进行，另一个方向上的则可同理得出。

---

插入（Insertion）
首先我们要了解的是，在不同情况下，节点的高度和平衡因子会发生变化呢？
假设：有节点N，h(N)=h0，现在有使N节点的左树高度增加1的插入。
(a) 当b(N)=≮时，由于h(N)=h0，故h(N.l)=h0-1，(N.r)=h0-2；插入后，h(N.l)=h0，h(N)=h0+1，高度增加，b(N)=≤；
(b) 当b(N)=⊥时，由于h(N)=h0，故h(N.l)=h0-1，(N.r)=h0-1；插入后，h(N.l)=h0，h(N)=h0+1，高度增加，b(N)=≮；
(c) 当b(N=≯时，由于h(N)=h0，故h(N.l)=h0-2，(N.r)=h0-1；插入后，h(N.l)=h0，h(N)=h0+1，高度不变，b(N)=⊥。
当N为叶节点时（h(N)=1，即N的左右子节点都为空），则只能发生情况(b)。显然，平衡性的变化可以在插入过程中由子节点的结果递归得出。

在插入后，以下三种情况都是稳定的：

不稳定这两种情况：

当出现这两种不稳定的情况时，我们就需要进行旋转（Rotations）。旋转的作用是改变原有的树的结构，但不破坏树的性质（事实上几乎所有的自平衡BST都会采用这几种旋转方式）。下面是一个典型的AVL旋转（左子节点的值小于父节点）：

继续前面假设的情境，由于(b)、(c)两种情况下，节点是稳定的，不需要调整；所以下面对情况(a)即插入后N的平衡因子为≤的情况进行讨论。[Note 1]
考虑N的左子节点的平衡因子变化：因为N的左子树高度增加了，所以N才需要调整，这意味着，N的左子节点L的平衡因子发生了变化。由于(a)情况是现在正在讨论的，问题是递归解决的，所以可以先不用考虑；而在(c)情况下L的平衡因子不会发生变化，L的高度不变，现在的环境不成立；所以L的变化只可能是情况(b)，即插入前的平衡性为⊥，插入后为其它两种平衡性之一（在递归中我们可用此判断是否需要进行旋转）。下面分两种情况进行讨论，即插入后L的平衡因子分别为≮、≯。

假设有节点D：插入前b(D)=≮，h(D.r)=h0；令B=D.l，则b(B)=⊥，h(B)=h0+1， h(B.l)=h(B.r)=h0。插入后，则h(B)= h0+2，b(D)=≮，需要根据插入后b(B)的情况进行调整（见下图）：

1. b(B)=≮。这种情况比较简单，图上很清楚，对D节点进行一次右旋即可。旋转后，原节点D被B代替，而B和D节点都恢复了平衡；和插入前相比，根节点高度没变；
2. b(B)=≯。图中很难看出来插入后b(C)=⊥，下面先证明：因为插入前h(C)=h0+1，故Max[h(L), h(R)]=h0，则h(L)<=h0，h(R)<=h0；又因为h(L)<=h(B)=h0，h(R)<=h(D)=h0，所以插入后，h(B)=Max[h(B.l), h(L)]=h0，h(D)=Max[h(D.r), h(R)]=h0，则b(C)=⊥得证。又因为插入后h(B)=h(D)=h0+1，所以旋转后与插入前的根节点的高度相同。

但插入后b(B)、b(D)需要根据插入前b(C)的情况来讨论：

• 插入前b(C)=⊥：则h(L)=h(R)=h0；插入后，b(B)=b(D)=⊥；
• 插入前b(C)=≮：则h(L)=h0，h(R)=h0-1；插入后，b(B)=⊥，b(D)=≯；
• 插入前b(C)=≯：则h(L)=h0-1，h(R)=h0；插入后，b(B)=≮，b(D)=⊥。

 这种情况的旋转虽然看起来比较复杂，但却可以看成两个连续的单次旋转：

总结

•  一个节点插入数据，当子节点高度增加时，平衡性向该方向增加；
•  出现节点不稳定的情况时，要进行旋转调整以保持节点的平衡性；
•  旋转有两种基本操作，单次左旋转和单次右旋转；
•  当节点不稳定时，根据其平衡性倾斜方向、该方向子节点的平衡性倾斜方向可分为4种情况：LL、LR、RL、RR（左左、左右、右左、右右）；分别对应右单旋（Single: Right Rotate），左右双旋（Double: Left-Right Rotate），右左双旋（Double: Right-Left Rotate），左单旋（Single: Left Rotate）；
•  旋转后，节点的平衡性恢复，且高度不增加。

室友的面试，被问了这道题。

http://www.cprogramming.com/tutorial/c-vs-c++.html

Gotchas for a C programmer using C++

Implicit Assignment from void*

You cannot implicitly assign from a void* to any other type. For instance, the following is perfectly valid in C (in fact, it's arguably the preferable way of doing it in C)

int *x = malloc(sizeof(int) * 10);

but it won't compile in C++. (Try it yourself!)

The explanation from Bjarne Stroustrup himself is that this isn't type safe. What this means is that you can have a void* that points to anything at all, and if you then assign the address stored in that void* to another pointer of a different type, there isn't any warning at all about it.

Consider the following:

int an_int;
void *void_pointer = &an_int;
double *double_ptr = void_pointer;
*double_ptr = 5;

When you assign *double_ptr the value 5, it's writing 8 bytes of memory, but the integer variable an_int is only 4 bytes. Forcing a cast from a void pointer makes the programmer pay attention to these things.

Freeing arrays: new[] and delete[]

In C, there's only one major memory allocation function: malloc. You use it to allocate both single elements and arrays:

int *x = malloc( sizeof(int) );
int *x_array = malloc( sizeof(int) * 10 );

and you always release the memory in the same way:

free( x );
free( x_array );

In C++, however, memory allocation for arrays is somewhat different than for single objects; you use the new[] operator, and you must match calls to new[] with calls to delete[] (rather than to delete).

int *x = new int;
int *x_array = new int[10];

delete x;
delete[] x;

The short explanation is that when you have arrays of objects, delete[] with properly call the destructor for each element of the array, whereas delete will not.

You must declare functions before use

Although most good C code will follow this convention, in C++ it is strictly enforced that all functions must be declared before they are used. This code is valid C, but it is not valid C++:

#include <stdio.h>
int main()
{
    foo();
    return 0;
}

int foo()
{
    printf( "Hello world" );
}

Gotcha for a C++ programmer using C

Structs and Enums

You have to include the struct keyword before the name of the struct type to declare a struct: In C++, you could do this

struct a_struct
{
    int x;
};

a_struct struct_instance;

and have a new instance of a_struct called struct_instance. In C, however, we have to include the struct keyword when declaring struct_instance:

struct a_struct struct_instance;

In fact, a similar situation also holds for declaring enums: in C, you must include the keyword enum; in C++, you don't have to. As a side note, most C programmers get around this issue by using typedefs:

typedef struct struct_name
{
    /* variables */
} struct_name_t;

Now you can declare a struct with

struct_name_t struct_name_t_instance;

But there is another gotcha for C++ programmers: you must still use the "struct struct_name" syntax to declare a struct member that is a a pointer to the struct.

typedef struct struct_name
{
    struct struct_name instance;
    struct_name_t instance2; /* invalid!  The typedef isn't defined yet */
} struct_name_t;

C++ has a much larger library

C++ has a much larger library than C, and some things may be automatically linked in by C++ when they are not with C. For instance, if you're used to using g++ for math-heavy computations, then it may come as a shock that when you are using gcc to compile C, you need to explicitly include the math library for things like sin or even sqrt:

% g++ foo.cc

or

% gcc foo.c -lm

No Boolean Type

C does not provide a native boolean type. You can simulate it using an enum, though:

typedef enum {FALSE, TRUE} bool;

main Doesn't Provide return 0 Automatically

In C++, you are free to leave off the statement 'return 0;' at the end of main; it will be provided automatically:

int main()
{
    printf( "Hello, World" );
}

but in C, you must manually add it:

int main()
{
    printf( "Hello, World" );
    return 0;
}

太远了，在上地的某某地方。经过这次笔试，我得出了一个结论：对于那些太远的，又没有太好的公司，就不要浪费那个劲去他们公司笔试了。

到了那边，没有人接待，随便找个角落工位就给笔试，周围的女人在肆无忌惮的聊天，昏暗的灯光，很沉闷。

呆实验室久了以后，再去别的公司，真是觉得那些公司的环境非常不够好。由俭入奢易，由奢入俭难啊！

笔完之后会给两个上机题，有个不错的男生给抵触。我也傻逼了，根本不适合的职位也投了。那个公司是需要windows下的vc开发。几百年没碰过vc了。。非常不习惯。。这又是一个经验，不要瞎投自己肯定不适合的地方。。 笔试题有2个，一个是mfc开发，图像处理，我直接没看。第二个是算法题，递归处理。

恰好昨天是入冬以来最冷的一天，-9~-2度。5-6级北风。回来的时候，坐在982公交车上，我的脑袋都快晕了。酒味，汽油味，小孩的奶味，汗味，什么味道都有。

这个人品攒的真是杠杠的

帅博鄙视我，不让我去这种鬼地方笔试。但是我为了攒rp还是去了。

还好很近，就在大柳树。办公室条件很破，还有人在使用17球面屏，我很诧异。好处是，里面很空荡，没什么人。hr告诉我，今天没有会议室可以笔试了，找个工位笔试吧。。这一幕好熟悉啊。。

hr给了我一份试卷和5张白纸。试卷上密密麻麻画了不少东西，hr告诉我，你不能在试卷上面写东西哦。我当下就不爽了，还好我情商够高，没表现出来。（堡爷就是这么牛逼！）。此时，我终于想起来，在那里见到过这种笔试场景了！！——在实验室啊。几张白纸，一份刚打印的试卷（我们实验室还更正轨，不是用别人考过的），由于没有会议室，只能在没来的同学的工位上进行笔试。

试卷不难，可以说是我做过的最简单的一个。很多基本知识，但是还是有一道JAVA的题目很偏，关于Long 与Short之间的比较的，我不会做。不过我根本不care，于是我在答题纸上老老实实的写上，“不会”。（并且JAVA与C++之中，只要选择一个做就好了，我选了C++）

然后有很多UML，软件工程之类的，不会做，不过这次我没有写“不会了”，太没个性了。我跳过了他们。

最后是很多选答题，名词解释啊，Hibernate啊，spring啊，等等等等，不是很care，随便答了一下。交卷了。写完给试卷编号时，我发现了，居然写了5页。。天啊，难怪手这么酸。

期间接到了雅虎口碑hr的电话，呵呵，给我一个北京的职位，恩。不错。rp守恒。那我晚上就不去阿里巴巴研究院笔试吗？去还是不去？这是一个问题。

记下几个不是很会的问题吧：

1，xml有几种解释方式？

2，有几种查询的方式？

3，OSI中每层的作用？（shit!）

本来是希望能够拿着这个offer，心理比较有底。。

哎，毁约太麻烦了，我还不想这么早就完全签了。

from 绿盟。

thx

转过来的。

选自《CSDN 社区电子杂志——C/C++杂志》
http://emag.csdn.net 2005 年1 月 总第1 期 - 93 -
本文作者：steedhorse（晨星）
printf 可能是许多程序员在开始学习C 语言时接触到的第二个函数（我猜第一个是main），说
起来，自然是老朋友了，可是，你对这个老朋友了解多吗？你对它的那个孪生兄弟sprintf 了解多
吗？在将各种类型的数据构造成字符串时，sprintf 的强大功能很少会让你失望。
由于sprintf 跟printf 在用法上几乎一样，只是打印的目的地不同而已，前者打印到字符串中，
后者则直接在命令行上输出。这也导致sprintf 比printf 有用得多。所以本文着重介绍sprintf，有时
也穿插着用用pritnf。
sprintf 是个变参函数，定义如下：
int sprintf( char *buffer, const char *format [, argument] ... );
除了前两个参数类型固定外，后面可以接任意多个参数。而它的精华，显然就在第二个参数：
格式化字符串上。
printf 和sprintf 都使用格式化字符串来指定串的格式，在格式串内部使用一些以“%”开头的
格式说明符（format specifications）来占据一个位置，在后边的变参列表中提供相应的变量，最终
函数就会用相应位置的变量来替代那个说明符，产生一个调用者想要的字符串。
格式化数字字符串
sprintf 最常见的应用之一莫过于把整数打印到字符串中，所以，spritnf 在大多数场合可以替代
itoa。如：
//把整数123 打印成一个字符串保存在s 中。
sprintf(s, "%d", 123); //产生"123"
可以指定宽度，不足的左边补空格：
sprintf(s, "%8d%8d", 123, 4567); //产生：" 123 4567"
当然也可以左对齐：
sprintf(s, "%-8d%8d", 123, 4567); //产生："123 4567"
也可以按照16 进制打印：
sprintf(s, "%8x", 4567); //小写16 进制，宽度占8 个位置，右对齐
sprintf(s, "%-8X", 4568); //大写16 进制，宽度占8 个位置，左对齐

这样，一个整数的16 进制字符串就很容易得到，但我们在打印16 进制内容时，通常想要一
种左边补0 的等宽格式，那该怎么做呢？很简单，在表示宽度的数字前面加个0 就可以了。
sprintf(s, "%08X", 4567); //产生："000011D7"
上面以”%d”进行的10 进制打印同样也可以使用这种左边补0 的方式。
这里要注意一个符号扩展的问题：比如，假如我们想打印短整数（short）-1 的内存16 进制表
示形式，在Win32 平台上，一个short 型占2 个字节，所以我们自然希望用4 个16 进制数字来打
印它：
short si = -1;
sprintf(s, "%04X", si);
产生“FFFFFFFF”，怎么回事？因为spritnf 是个变参函数，除了前面两个参数之外，后面的
参数都不是类型安全的，函数更没有办法仅仅通过一个“%X”就能得知当初函数调用前参数压栈
时被压进来的到底是个4 字节的整数还是个2 字节的短整数，所以采取了统一4 字节的处理方式，
导致参数压栈时做了符号扩展，扩展成了32 位的整数-1，打印时4 个位置不够了，就把32 位整数
-1 的8 位16 进制都打印出来了。如果你想看si 的本来面目，那么就应该让编译器做0 扩展而不是
符号扩展（扩展时二进制左边补0 而不是补符号位）：
sprintf(s, "%04X", (unsigned short)si);
就可以了。或者：
unsigned short si = -1;
sprintf(s, "%04X", si);
sprintf 和printf 还可以按8 进制打印整数字符串，使用”%o”。注意8 进制和16 进制都不会打
印出负数，都是无符号的，实际上也就是变量的内部编码的直接的16 进制或8 进制表示。
控制浮点数打印格式
浮点数的打印和格式控制是sprintf 的又一大常用功能，浮点数使用格式符”%f”控制，默认保
留小数点后6 位数字，比如：
sprintf(s, "%f", 3.1415926); //产生"3.141593"
但有时我们希望自己控制打印的宽度和小数位数，这时就应该使用：”%m.nf”格式，其中m 表
示打印的宽度，n 表示小数点后的位数。比如：
sprintf(s, "%10.3f", 3.1415626); //产生：" 3.142"
sprintf(s, "%-10.3f", 3.1415626); //产生："3.142 "
sprintf(s, "%.3f", 3.1415626); //不指定总宽度，产生："3.142"
注意一个问题，你猜
int i = 100;
sprintf(s, "%.2f", i);
会打出什么东东来？“100.00”？对吗？自己试试就知道了，同时也试试下面这个：
sprintf(s, "%.2f", (double)i);
第一个打出来的肯定不是正确结果，原因跟前面提到的一样，参数压栈时调用者并不知道跟i
相对应的格式控制符是个”%f”。而函数执行时函数本身则并不知道当年被压入栈里的是个整数，
于是可怜的保存整数i 的那4 个字节就被不由分说地强行作为浮点数格式来解释了，整个乱套了。
不过，如果有人有兴趣使用手工编码一个浮点数，那么倒可以使用这种方法来检验一下你手
工编排的结果是否正确。?
字符/Ascii 码对照
我们知道，在C/C++语言中，char 也是一种普通的scalable 类型，除了字长之外，它与short，
int，long 这些类型没有本质区别，只不过被大家习惯用来表示字符和字符串而已。（或许当年该把
这个类型叫做“byte”，然后现在就可以根据实际情况，使用byte 或short 来把char 通过typedef 定
义出来，这样更合适些）
于是，使用”%d”或者”%x”打印一个字符，便能得出它的10 进制或16 进制的ASCII 码；反过
来，使用”%c”打印一个整数，便可以看到它所对应的ASCII 字符。以下程序段把所有可见字符的
ASCII 码对照表打印到屏幕上（这里采用printf，注意”#”与”%X”合用时自动为16 进制数增加”0X”
前缀）：
for(int i = 32; i < 127; i++) {
printf("[ %c ]: %3d 0x%#04X\n", i, i, i);
}
连接字符串
sprintf 的格式控制串中既然可以插入各种东西，并最终把它们“连成一串”，自然也就能够连
接字符串，从而在许多场合可以替代strcat，但sprintf 能够一次连接多个字符串（自然也可以同时
在它们中间插入别的内容，总之非常灵活）。比如：
char* who = "I";
char* whom = "CSDN";
sprintf(s, "%s love %s.", who, whom); //产生："I love CSDN. "
strcat 只能连接字符串（一段以’\0’结尾的字符数组或叫做字符缓冲，null-terminated-string），
但有时我们有两段字符缓冲区，他们并不是以’\0’结尾。比如许多从第三方库函数中返回的字符数
组，从硬件或者网络传输中读进来的字符流，它们未必每一段字符序列后面都有个相应的’\0’来结
尾。如果直接连接，不管是sprintf 还是strcat 肯定会导致非法内存操作，而strncat 也至少要求第
一个参数是个null-terminated-string，那该怎么办呢？我们自然会想起前面介绍打印整数和浮点数
时可以指定宽度，字符串也一样的。比如：
char a1[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G'};
char a2[] = {'H', 'I', 'J', 'K', 'L', 'M', 'N'};
如果：
sprintf(s, "%s%s", a1, a2); //Don't do that!
十有八九要出问题了。是否可以改成：
sprintf(s, "%7s%7s", a1, a2);
也没好到哪儿去，正确的应该是：
sprintf(s, "%.7s%.7s", a1, a2);//产生："ABCDEFGHIJKLMN"
这可以类比打印浮点数的”%m.nf”，在”%m.ns”中，m 表示占用宽度（字符串长度不足时补空
格，超出了则按照实际宽度打印），n 才表示从相应的字符串中最多取用的字符数。通常在打印字
符串时m 没什么大用，还是点号后面的n 用的多。自然，也可以前后都只取部分字符：
sprintf(s, "%.6s%.5s", a1, a2);//产生："ABCDEFHIJKL"
在许多时候，我们或许还希望这些格式控制符中用以指定长度信息的数字是动态的，而不是
静态指定的，因为许多时候，程序要到运行时才会清楚到底需要取字符数组中的几个字符，这种
动态的宽度/精度设置功能在sprintf 的实现中也被考虑到了，sprintf 采用”*”来占用一个本来需要一
个指定宽度或精度的常数数字的位置，同样，而实际的宽度或精度就可以和其它被打印的变量一
样被提供出来，于是，上面的例子可以变成：
sprintf(s, "%.*s%.*s", 7, a1, 7, a2);
或者：
sprintf(s, "%.*s%.*s", sizeof(a1), a1, sizeof(a2), a2);
实际上，前面介绍的打印字符、整数、浮点数等都可以动态指定那些常量值，比如：
sprintf(s, "%-*d", 4, 'A'); //产生"65 "
sprintf(s, "%#0*X", 8, 128); //产生"0X000080"，"#"产生0X
sprintf(s, "%*.*f", 10, 2, 3.1415926); //产生" 3.14"
打印地址信息
有时调试程序时，我们可能想查看某些变量或者成员的地址，由于地址或者指针也不过是个32 位的数，你完全可以使用打印无符号整数的”%u”把他们打印出来：
sprintf(s, "%u", &i);
不过通常人们还是喜欢使用16 进制而不是10 进制来显示一个地址：
sprintf(s, "%08X", &i);
然而，这些都是间接的方法，对于地址打印，sprintf 提供了专门的”%p”：
sprintf(s, "%p", &i);
我觉得它实际上就相当于：
sprintf(s, "%0*x", 2 * sizeof(void *), &i);
利用sprintf 的返回值
较少有人注意printf/sprintf 函数的返回值，但有时它却是有用的，spritnf 返回了本次函数调用
最终打印到字符缓冲区中的字符数目。也就是说每当一次sprinf 调用结束以后，你无须再调用一次
strlen 便已经知道了结果字符串的长度。如：
int len = sprintf(s, "%d", i);
对于正整数来说，len 便等于整数i 的10 进制位数。
下面的是个完整的例子，产生10 个[0, 100)之间的随机数，并将他们打印到一个字符数组s 中，
以逗号分隔开。
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int main() {
srand(time(0));
char s[64];
int offset = 0;
for(int i = 0; i < 10; i++) {
offset += sprintf(s + offset, "%d,", rand() % 100);
}
s[offset - 1] = '\n';//将最后一个逗号换成换行符。
printf(s);
return 0;
}
设想当你从数据库中取出一条记录，然后希望把他们的各个字段按照某种规则连接成一个字
符串时，就可以使用这种方法，从理论上讲，他应该比不断的strcat 效率高，因为strcat 每次调用
都需要先找到最后的那个’\0’的位置，而在上面给出的例子中，我们每次都利用sprintf 返回值把这
个位置直接记下来了。
使用sprintf 的常见问题
sprintf 是个变参函数，使用时经常出问题，而且只要出问题通常就是能导致程序崩溃的内存访
问错误，但好在由sprintf 误用导致的问题虽然严重，却很容易找出，无非就是那么几种情况，通
常用眼睛再把出错的代码多看几眼就看出来了。
?? 缓冲区溢出
第一个参数的长度太短了，没的说，给个大点的地方吧。当然也可能是后面的参数的问
题，建议变参对应一定要细心，而打印字符串时，尽量使用”%.ns”的形式指定最大字符数。
?? 忘记了第一个参数
低级得不能再低级问题，用printf 用得太惯了。//偶就常犯。：。（
?? 变参对应出问题
通常是忘记了提供对应某个格式符的变参，导致以后的参数统统错位，检查检查吧。尤
其是对应”*”的那些参数，都提供了吗？不要把一个整数对应一个”%s”，编译器会觉得你
欺她太甚了（编译器是obj 和exe 的妈妈，应该是个女的，:P）。
strftime
sprnitf 还有个不错的表妹：strftime，专门用于格式化时间字符串的，用法跟她表哥很像，也
是一大堆格式控制符，只是毕竟小姑娘家心细，她还要调用者指定缓冲区的最大长度，可能是为
了在出现问题时可以推卸责任吧。这里举个例子：
time_t t = time(0);
//产生"YYYY-MM-DD hh:mm:ss"格式的字符串。
char s[32];
strftime(s, sizeof(s), "%Y-%m-%d %H:%M:%S", localtime(&t));
sprintf 在MFC 中也能找到他的知音：CString::Format，strftime 在MFC 中自然也有她的同道：
CTime::Format，这一对由于从面向对象哪里得到了赞助，用以写出的代码更觉优雅。

我复制过来的：   

     如果试图直接使用C++的成员函数作为回调函数将发生错误，甚至编译就不能通过。通过查询资料发现，其错误是普通的C++成员函数都隐含了一个传递函数作为参数，亦即“this”指针，C++通过传递一个指向自身的指针给其成员函数从而实现程序函数可以访问C++的数据成员。这也可以理解为什么C++类的多个实例可以共享成员函数但是确有不同的数据成员。由于this指针的作用，使得将一个CALLBACK型的成员函数作为回调函数安装时就会因为隐含的this指针使得函数参数个数不匹配，从而导致回调函数安装失败。要解决这一问题的关键就是不让this指针起作用，通过采用以下两种典型技术可以解决在C++中使用回调函数所遇到的问题。这种方法具有通用性，适合于任何C++。  
   
　　1).   不使用成员函数，直接使用普通C函数，为了实现在C函数中可以访问类的成员变量，可以使用友元操作符(friend)，在C++中将该C函数说明为类的友元即可。这种处理机制与普通的C编程中使用回调函数一样。  
   
　　2).   使用静态成员函数，静态成员函数不使用this指针作为隐含参数，这样就可以作为回调函数了。静态成员函数具有两大特点：其一，可以在没有类实例的情况下使用；其二，只能访问静态成员变量和静态成员函数，不能访问非静态成员变量和非静态成员函数。由于在C++中使用类成员函数作为回调函数的目的就是为了访问所有的成员变量和成员函数，如果作不到这一点将不具有实际意义。解决的办法也很简单，就是使用一个静态类指针作为类成员，通过在类创建时初始化该静态指针，如pThis=this，然后在回调函数中通过该静态指针就可以访问所有成员变量和成员函数了。这种处理办法适用于只有一个类实例的情况，因为多个类实例将共享静态类成员和静态成员函数，这就导致静态指针指向最后创建的类实例。为了避免这种情况，可以使用回调函数的一个参数来传递this指针，从而实现数据成员共享。这种方法稍稍麻烦，这里就不再赘述。

举例：

class Test
{
public:

    static void callBackFun(void){}; //因为callBackFun默认有一个const Test* 的指针
};

typedef void (*FPtr)(void);

void Fun(FPtr ptr)
{
    ptr();
}

void main(void)
{
    Fun(Test::callBackFun);
}

很多很多题，写的手都酸了。铅笔笔芯都写没了。。

总结一下不会做的，或者不熟练的。

1，KMP不熟了，用了strstr函数。。傻逼大了，strstr返回的是char *。extern char *strstr(char *haystack, char *needle); 日。。应该用他的返回值 - haystack 实现JAVA中的 indexOf功能。。

2，多线程编程 ，用java写的，没有具体的处理线程内部的输入输出。

3，RSTP，RSN,RTCP的意思和区别？

4，堆的建立方法

5，m*n矩阵中，联通区域的个数。

6，欧拉回路

7，视频解码的输入输出

8，播放器的模块数目

有个heap的实现。看不台东