算法题目：有两个字符串由不同的字母组成，一长一短，长的为A短的为B。设计一个算法，如果所有在B中出现的字符都在A中出现，则返回true，否则返回false。
例子：

如下字符串：

字符串A: abddfdioegdddffsfagj
字符串B: dofsjadg

字符串B中每个字符都在A中出现，返回true。

如下字符串：

字符串A: aaaabbbbbbdddddd
字符串B: acc

字符串B中有字符没在A中出现，返回false。

这只是个很基础的算法题目，相信很多人都能够立刻想出答案。

答案1：对字符串B中的每个字母在A中都遍历一遍。这个答案很烂，其时间复杂度为O(n*m)

答案2：设一个哈希表，对字符串A的字符遍历，将每个字符对应的哈希表中的值设为1。然后对B中的字符进行遍历，如果所有字符对应的hash值都为1，则返回true，否则返回false。

这个答案的时间复杂度是O(m+n)，应该是大多数面试者想要的答案，相信大多数人也能想到。这样结束了？如果真结束了，那就谈不上有趣了！如果我们对空间要求比较高该怎么办？

答案3：我们可以观察到，字母总共就有26个，而且在上面答案中，hash表的值只有1和0两种情况。那就好办了，我们知道int类型是32位，如果用1位(bit)来表示一个字母是否出现，那么只需1个int类型就能够表示所有的字母了。

答案3实际上跟答案2类似，换汤不换药。有趣的不是他，实际上还存在一种更有意思的方法：

答案4：我们为每个字母(假设字母的数量是一定的)分配一个不重复素数，比如a为2， b为3， c为5，以此类推。这样在对字符串A进行遍历时，将每个字符表示的素数相乘，最终得到一个比较大的整数。然后从字符串B中第一个字母开始，用每个字母所代表的数除这个整数，如果余数不为0，那么就返回false。如果整个遍历过程中都没有余数，则返回true。

在我第一次从原文中看到着个答案的时候，有一种眼前一亮的感觉。实际上仔细推敲，这种算法的效率并不一定比之前的答案要高，因为往往一个乘法/除法的效率要小于加减法或者比较运算。但是却给出了一种全新的考虑问题的角度，有种奇思妙想的感觉！这种方法更为巧妙，有趣！

在每个算法题目中，你在得到一个公认的比较有效的方法后，是否考虑过更简单、有趣的方法呢？

ERROR: Error 65280 occurred while making /var/tmp/portage/app-office/openoffice-3.2.1-r1/work/ooo/build/OOO320_m19/desktop/zipintro 
rmdir /var/tmp/portage/app-office/openoffice-3.2.1-r1/temp/yERj5YXC9A 
make: *** [stamp/build] Error 1 
* ERROR: app-office/openoffice-3.2.1-r1 failed: 
* Build failed 
* 
* Call stack: 
* ebuild.sh, line 54: Called src_compile 
* environment, line 8141: Called die 
* The specific snippet of code: 
* make || die "Build failed" 
* 
* If you need support, post the output of 'emerge --info =app-office/openoffice-3.2.1-r1', 
* the complete build log and the output of 'emerge -pqv =app-office/openoffice-3.2.1-r1'. 
!!! When you file a bug report, please include the following information: 
GENTOO_VM=sun-jdk-1.6 CLASSPATH="" JAVA_HOME="/opt/sun-jdk-1.6.0.22" 
JAVACFLAGS="-source 1.5 -target 1.5" COMPILER="" 
and of course, the output of emerge --info 
* The complete build log is located at '/var/log/portage/app-office:openoffice-3.2.1-r1:20101120-141010.log'. 
* The ebuild environment file is located at '/var/tmp/portage/app-office/openoffice-3.2.1-r1/temp/environment'. 
* S: '/var/tmp/portage/app-office/openoffice-3.2.1-r1/work/ooo' 
 
>>> Failed to emerge app-office/openoffice-3.2.1-r1, Log file: 
 
>>> '/var/log/portage/app-office:openoffice-3.2.1-r1:20101120-141010.log'

问题原因：openoffice依赖一个包imagemagick，该包编译时需要png。具体机制不详

解决方法： USE="png" emerge -av imagemagick openoffice

2、在root下面无法启动gedit等gui软件
错误提示为：

(gedit:5278): EggSMClient-WARNING **: Failed to connect to the session manager: None of the authentication protocols specified are supported 
 
** 
GLib-GIO:ERROR:gdbusconnection.c:2271:initable_init: assertion failed: (connection->initialization_error == NULL) 
Aborted

问题原因：su进入root后，只是简单的切换user，并不能提供一个全root的运行环境
解决方法： 使用 su - 代替 su。 注意su和-之间有个空格。

3、firefox字体模糊
问题原因：系统开启了抗锯齿效果
解决方法： 在/etc/fonts/fonts.conf文件中添加：

 <match target="font">
                <test name="family" compare="eq">
                        <string>SimSun</string>"or"
                        <string>Bitstream Cyberbit</string>"or"
                        <string>AR PL KaitiM Big5</string>"or"
                        <string>AR PL Mingti2L Big5</string>"or"
                        <string>AR PL KaitiM GB</string>"or"
                        <string>AR PL SungtiL GB</string>
                </test>
                <edit name="hinting" mode="assign">
                        <bool>true</bool>
                </edit>
                <edit name="autohint" mode="assign">
                        <bool>true</bool>
                </edit>
                <edit name="antialias" mode="assign">
                        <bool>false</bool>
                </edit>
</match>

4、在安装klibc过程中出现大致如下的错误

 * Applying klibc-1.5.11-x86_64-io.h-return.diff ...                                                                                                            [ ok ] 
>>> Source unpacked in /var/tmp/portage/dev-libs/klibc-1.5.15-r1/work 
>>> Compiling source in /var/tmp/portage/dev-libs/klibc-1.5.15-r1/work/klibc-1.5.15 ... 
make -j3 defconfig CC=x86_64-pc-linux-gnu-gcc HOSTCC=x86_64-pc-linux-gnu-gcc 
Makefile:434: *** mixed implicit and normal rules.  Stop. 
emake failed 
 * ERROR: dev-libs/klibc-1.5.15-r1 failed: 
 *   No defconfig 
 * 
 * Call stack: 
 *     ebuild.sh, line  56:  Called src_compile 
 *   environment, line 2425:  Called die 
 * The specific snippet of code: 
 *       emake ${defconfig} CC="${CC}" HOSTCC="${HOSTCC}" || die "No defconfig"; 
 * 
 * If you need support, post the output of 'emerge --info =dev-libs/klibc-1.5.15-r1', 
 * the complete build log and the output of 'emerge -pqv =dev-libs/klibc-1.5.15-r1'. 
 * The complete build log is located at '/var/tmp/portage/dev-libs/klibc-1.5.15-r1/temp/build.log'. 
 * The ebuild environment file is located at '/var/tmp/portage/dev-libs/klibc-1.5.15-r1/temp/environment'. 
 * S: '/var/tmp/portage/dev-libs/klibc-1.5.15-r1/work/klibc-1.5.15' 
 
>>> Failed to emerge dev-libs/klibc-1.5.15-r1, Log file: 
 
>>>  '/var/tmp/portage/dev-libs/klibc-1.5.15-r1/temp/build.log' 
 
 * Messages for package dev-libs/klibc-1.5.15-r1: 
 
 * ERROR: dev-libs/klibc-1.5.15-r1 failed: 
 *   No defconfig 
 * 
 * Call stack: 
 *     ebuild.sh, line  56:  Called src_compile 
 *   environment, line 2425:  Called die 
 * The specific snippet of code: 
 *       emake ${defconfig} CC="${CC}" HOSTCC="${HOSTCC}" || die "No defconfig"; 
 * 
 * If you need support, post the output of 'emerge --info =dev-libs/klibc-1.5.15-r1', 
 * the complete build log and the output of 'emerge -pqv =dev-libs/klibc-1.5.15-r1'. 
 * The complete build log is located at '/var/tmp/portage/dev-libs/klibc-1.5.15-r1/temp/build.log'. 
 * The ebuild environment file is located at '/var/tmp/portage/dev-libs/klibc-1.5.15-r1/temp/environment'. 
 * S: '/var/tmp/portage/dev-libs/klibc-1.5.15-r1/work/klibc-1.5.15'

问题原因：高版本make的一个bug
解决方法： 编译klibc的时候先将make版本降低

emerge --oneshot =make-3.80-r4 
emerge --oneshot klibc

编译完成后再将版本升级回来

emerge --update --oneshot make

参考：

http://forums.gentoo.org/viewtopic-t-849190.html?sid=d33383354a919e3ebabba9b36edd2d4e

http://bugs.gentoo.org/345743

http://forums.fedoraforum.org/archive/index.php/t-255624.html

对于结构体和空类大小是1这个问题，首先这是一个C++问题，在C语言下空结构体大小为0(当然这是编译器相关的)。这里的空类和空结构体是指类或结构体中没有任何成员。

在C++下，空类和空结构体的大小是1（编译器相关），这是为什么呢？为什么不是0？

这是因为，C++标准中规定，“no object shall have the same address in memory as any other variable” ，就是任何不同的对象不能拥有相同的内存地址。 如果空类大小为0，若我们声明一个这个类的对象数组，那么数组中的每个对象都拥有了相同的地址，这显然是违背标准的。

但是，也许你还有一个疑问，为什么C++标准中会有这么无聊的规定呢？

当然，这样规定显然是有原因的。我们假设C++中有一个类型T，我们声明一个类型T的数组，然后再声明一个T类型的指针指向数组中间某个元素，则我们将指针减去1，应该得到数组的另一个索引。如下代码：

1
2
3
4
5

T array[5];
 
int diff = &array[3] - &array[2];
 
 // diff = 1

上面的代码是一种指针运算，将两个指针相减，编译器作出如下面式子所示的动作：

diff = ((char *)&array[3] - (char *)&array[2]) / sizeof T;

式子应该不难懂把，很明显的一点就是这个式子的计算依赖于sizeof T。虽然上面只是一个例子，但是基本上所有的指针运算都依赖于sizeof T。

好，下面我们来看，如果允许不同的对象有相同的地址将会引发什么样的问题，看下面的例子：

1
2
3
4

 &array[3] - &array[2] = &array[3] - &array[1]
                       = &array[3] - &array[1]
                       = &array[3] - &array[0]
                       = 0

我们可以看到，在这个例子中，如果每个对象都拥有相同地址，我们将没有办法通过指针运算来区分不同的对象。还有一个更严重的问题，就是如果 sizeof T是0，就会导致编译器产生一个除0的操作，引发不可控的错误。

基于这个原因，如果允许结构体或者类的大小为0，编译器就需要实现一些复杂的代码来处理这些异常的指针运算。

所以，C++标准规定不同的对象不能拥有相同的地址。那么怎样才能保证这个条件被满足呢？最简单的方法莫过于不允许任何类型的大小为0。所以编译器为每个空类或者空结构体都增加了一个虚设的字节（有的编译器可能加的更多），这样这些空类和空结构的大小就不会是0，就可以保证他们的对象拥有彼此独立的地址。

sizeof(int);
sizeof(char);
sizeof(double);

上面三行sizeof的值是多少呢？这里我们假定在32位的x86系统下。我们会得到答案：4，1，8。这个没什么吧，大多数人都应该知道。那么，下面这个：

sizeof(int);
sizeof(long);

在32位x86下，这两个是多少呢？4，8？

实际上，答案是4，4。我们需要注意，long类型在32位系统下是32位的。那么，64位下结果又如何呢？8，8？其实答案是4，8。另一个需要注意的是，64位下的int是32位的。

上面只是热热身，现在，让我们看sizeof的下面几种情形：

1、sizeof一个结构体。

这个我就不说啥了，具体的参考这篇文章。至于空的结构体，下面会解释。

2、sizeof数组、指针等 先看下面两个例子：

char a[100];
char b[100]="helloworld!";
char c[]="helloworld!";
char* d=b;
sizeof(a);
sizeof(b);
sizeof(c);
sizeof(d);

在32位x86系统下，以上各是多少呢？

答案是：100，100，12，4。

为什么不是100，12，12，12呢？ sizeof一个数组名，返回的是数组的大小，不管你数组里面放的什么数据。所以，第一个数组大小是100，第二个数组大小是100，第三个数组大小是12（别忘记"\0"）。第四个呢？第四个不是一个数组名，而是一个指针！32位下指针大小永远是4，不管你是指向一个数组还是一个int还是一个char。 好，这个问题搞清楚之后，看下面这个程序：

int func(char a[100])
{
    printf("%d\n", sizeof(a));
}
int main()
{
    char *m = "helloworld!";
    func(m);
    char n[100]="helloworld!";
    func(n);
}

这个程序会打印出什么结果呢？

答案是：4， 4。 为什么结果都是4？不是应该返回数组长度么？

这里出现又一个需要注意的地方：在作为参数传递的时候，数组名会退化为指针。也就是说，这里的func里的参数，虽然看上去是个数组名，但实际上还是个指针。 你了解了么？下面是几个练习，自己实验下^_^

char *p = NULL;
sizeof(p);
sizeof(*p);
 
int a[100];
sizeof(a);
sizeof(a[100]);
sizeof(&a);
sizeof(&a[0]);

懒得实验？答案分别是4，1，400，4，4，4。为什么？自己想想。

3、sizeof一些诡异的东西

（enum，空类，空struct） 所谓的诡异的东西，就是一些你想到的想不到的东西拿来sizeof。比如说sizeof一个enum类型是多少？一个空struct呢？一个空类呢？ 这些诡异的东西在标准C中都没有作出规定，很大程度上都是编译器和系统结构相关的。 先来看一个：

int main()
{
    enum week{Mon, Tue, Wed, Thu, Fri, Sat, Sun};
    printf("%d\n", sizeof(enum week));
}

这个你会得到什么样的结果呢？28？ 在gcc或者vc下运行一把，你会得到答案：4。

为什么呢？ 实际上，enum具体有多大取决于编译器的实现，目前大多数的编译器都将其实现为int类型。也就是说这里的enum被当作int类型（当然，使用上不一样）。这不是一成不变的，有些编译器，如VC++允许下面这种定义：

//注意这是个cpp文件
enum Color : unsigned char
{
   red, green, blue
};
// assert(sizeof(Color) == 1);

enum先说到这里，那么一个空的结构体是多大呢？ 如果你擅长C语言，你可以很快的写出下面的程序：

//this is a *.c file
struct node{
 
}Node;
int main
{
    printf("%d\n", sizeof(Node));
}

很快，你可以验证出来结果是0。 没错，这很好理解。但是，如果你用的是c++呢？

//this is a *.cpp file
struct node{
 
}Node;
 
class node2{
 
}Node2;
 
int main()
{
    printf("%d\n", sizeof(Node));
    printf("%d\n", sizeof(Node2));
}

（不怎么会写c++的我表示压力很大）以上这个c++的例子结果是多少呢？

为什么会得到1，1这个结果呢？ 换句话说就是为什么sizeof一个空类和空结构体在c++下就是1呢？

这个原因要追朔到c++标准中的一句话：“no object shall have the same address in memory as any other variable”， 用中国话简单点说就是：不同的对象之间应该有不同的地址（为什么会有这样的规定？看这里）。

既然每个对象都必须有不同的地址，让我们假设上面代码中的Node的size是0，想想会出现什么样的后果？

Node a;
Node b;

a的大小是0，b的大小是0，那么，a和b的地址是不是很可能重复了？

所以，为了保证不同的对象拥有不同的地址，最简单的方法就是保证所有类型的大小都不是0。

所以，为了保证这点，大多数c++编译器都会给空结构或类加上一个冗余的字节保证类型不为空。

我的解释的清楚么？如果我的表达能力不够好，看这里，解释的足够详细。 当然，还有其他很多我没有想到的诡异的东西可以拿来sizeof，如果你想到了，欢迎跟我分享。至于c++中的sizeof类，基类，派生类，足够可以作为一个专门的文章了，先不再这里说，等我学会C++的再写一下相关内容（-_-"）。

最后，给一个稍微给力点的程序，大家看看最终得到的结果是什么(注意这是一个c++程序)：

//this is a cpp file
typedef   struct   weekday_st
{
        enum   week     {sun=123456789,mon,tue,wed,thu,fri,sat,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,aa,ab,ac,ad,ae,af,ag,ah,ai,aj,ak};
        enum   day{monring,   moon,   aftermoon};
}weekday_st;
 
int   main(int   argc,   char   *argv[])
{
        printf( "sizeof(weekday_st)=%d\n ",   sizeof(weekday_st));
        printf( "sizeof(weekday)=%d\n ",   sizeof(weekday_st::week));
        printf( "sizeof(day)=%d\n ",   sizeof(weekday_st::day));
        return  0;
}

参考书目：《C专家编程》 《C语言深度解剖:解开程序员面试笔试的秘密 》

是阿，gdb凭什么可以调试一个程序？凭什么能够接管一个程序的运行？我以前也想过这样的问题，但是后来居然忘记去查看了。我想到了我们的二进制翻译器，想到了intel的pin，Dynamo。这些都是将翻译后的代码放到codecache中去运行，然后接管整个程序的执行。gdb是不是也一样呢？

如果真是这样，为什么我记得用gdb跑一个程序，这个程序会有一个单独的进程？gdb的attach功能又是怎么实现的？

想了想，我还是没有答上来。面试就是由这么一个又一个细节的小杯具最后汇集成一个大杯具。

那么，gdb到底是凭什么接管的一个进程的执行呢？其实，很简单，通过一个系统调用：ptrace。ptrace系统调用的原型如下：

#include <sys/ptrace.h>
 
long ptrace(enum __ptrace_request request, pid_t pid,
                   void *addr, void *data);

说明：ptrace系统调用提供了一种方法来让父进程可以观察和控制其它进程的执行，检查和改变其核心映像以及寄存器。 主要用来实现断点调试和系统调用跟踪。（man手册）

其实，说到这里，一切原理层面应该都比较明朗了（且先不去管内核中是怎么实现ptrace的）。gdb就是调用这个系统调用，然后通过一些参数来控制其他进程的执行的。

下面我们来看ptrace函数中request参数的一些主要选项：

PTRACE_TRACEME： 表示本进程将被其父进程跟踪，交付给这个进程的所有信号，即使信号是忽略处理的（除SIGKILL之外），都将使其停止，父进程将通过wait()获知这一情况。

这是什么意思呢？我们可以结合到gdb上来看。如果在gdb中run一个程序，首先gdb会fork一个子进程，然后该子进程调用ptrace系统调用，参数就是PTRACE_TRACEME，然后调用一个exec执行程序。基本过程是这样，细节上可能会有出入。需要注意的是，这个选项PTRACE_TRACEME是由子进程调用的而不是父进程！

以下选项都是由父进程调用：

PTRACE_ATTACH：attach到一个指定的进程，使其成为当前进程跟踪的子进程，而子进程的行为等同于它进行了一次PTRACE_TRACEME操作。但是，需要注意的是，虽然当前进程成为被跟踪进程的父进程，但是子进程使用getppid()的到的仍将是其原始父进程的pid。

这下子gdb的attach功能也就明朗了。当你在gdb中使用attach命令来跟踪一个指定进程/线程的时候，gdb就自动成为改进程的父进程，而被跟踪的进程则使用了一次PTRACE_TRACEME，gdb也就顺理成章的接管了这个进程。

PTRACE_CONT：继续运行之前停止的子进程。可同时向子进程交付指定的信号。

这个选项呢，其实就相当于gdb中的continue命令。当你使用continue命令之后，一个被gdb停止的进程就能继续执行下去，如果有信号，信号也会被交付给子进程。

除了以上这几个选项，ptrace还有很多其他选项，可以在linux下阅读man手册：man ptrace

需要注意的另一点是，使用gdb调试过多线程/进程的人应该都知道，当子进程遇到一个信号的时候，gdb就会截获这个信号，并将子进程暂停下来。这是为什么呢？

实际上，在使用参数为PTRACE_TRACEME或PTRACE_ATTACH的ptrace系统调用建立调试关系之后，交付给目标程序的任何信号（除SIGKILL之外）都将被gdb先行截获，或在远程调试中被gdbserver截获并通知gdb。gdb因此有机会对信号进行相应处理，并根据信号的属性决定在继续目标程序运行时是否将之前截获的信号实际交付给目标程序。

参考资料：gdb的基本工作原理
《gdb pocket reference》

问的问题不难，都是基础，可是自己不争气，答的不怎么样，一直自诩C语言用的很不错，可是还是在基础上被鄙视－ －！都是那些个关键字们阿～今天，让我挨个把C的关键字给详细的整一整，加深一下印象～

首先，C语言中到底有多少个关键字呢？木有错，ANSI C规定是32个！ 他们分别是：auto double int struct break else long switch case enum register typedef char extern return union const float short unsigned continue for signed void default goto sizeof volatile do if while static。

别看那一堆了字母了，直接看下面的分类介绍：

第一类：数据类型关键字

这一类别的关键字有：

char          //声明字符型变量或函数
double       //声明双精度变量或函数
enum         //声明枚举类型
float          //声明浮点型变量或函数
int            //声明整型变量或函数
long          //声明长整型变量或函数
short         //声明短整型变量或函数
signed       //声明有符号类型变量或函数
struct        //声明结构体变量或函数
union         //声明共用体数据类型
unsigned     //声明无符号类型变量或函数
void           //声明函数无返回值或无参数，声明无类型指针

这一类别的关键字无需过多的说明，基本都是我们经常用到的，但是，仍然有些是我们需要注意的东西：

1. C 标准并未定义指针、整数型（int）、长型（long）为特定的位数目。在32位体系结构下，一般int和long都是32位长；值得注意的是，64位机器下，很多程序设计环境，“int”变量仍然是 32 位宽，“long”和指针是 64 位宽。注意，这里说的只是一般情况下！详细的解释可以看这里。
2. union声明的联合数据结构，里面的数据是共享内存的，可以看我的另一篇日志。
3. unsigned声明的是一个无符号数据类型，也就是说，如果unsigned int i; 需要注意变量i永远不可能等于复数，除非强制类型转换。

第二类：控制语句关键字

for         //循环语句
do         //循环语句的循环体
while      //循环语句的循环条件
break     //跳出当前循环
continue //结束当前循环，开始下一次循环
if           //条件分支语句
else       //条件分支语句
goto      //无条件跳转语句
switch    //不解释
case      //不解释
default    //不解释
return     //返回语句

这些关键字估计都快被用烂了吧？不解释！

下面，开始做点有意义的事情，着重解释以下的关键字：

第三类：存储类型关键字

auto
extern
register
static

让我们一一来看这四个关键字：

1、auto关键字： 声明变量的生存期为自动，即将不在任何类、结构、枚举、联合和函数中定义的变量视为全局变量，而在函数中定义的变量视为局部变量。不明白？无视他好了，编译器默认的缺省情况下，所有的变量都是auto的。

2、extern关键字： 我们都知道，一个变量或函数，可以在a.c文件中定义，而在b.c文件中使用，这个时候，b.c就需要使用extern关键字来声明这个变量和函数，目的是为了告诉编译器，这个函数在b.c之外，别让我编译不过！

3、register关键字： 这个关键字就很少用到了，但是却十分有用。它的目的是告诉编译器尽量把这个变量放到寄存器中，这样提高存取速度，但是不是能真的放到寄存器中却不一定，毕竟寄存器的数量是有限的。在我们的二进制翻译器中，这个关键字被巧妙的用于线程切换。

4、static关键字： 好吧，我承认我土了，我就是栽在这个关键字上的。static有两种修饰，分别如下：

(1)修饰变量：变量分为全局变量和静态变量，都存储在内存的静态区中。

首先，当static修饰全局变量的时候，该变量的作用域仅被限定在当前文件中，别的文件即使使用extern关键字也无法使用这个变量。

其次，当static修饰局部变量的时候，该变量在哪个函数体中定义，就只能在哪个函数体中使用。也许你会说，这不跟普通局部变量一样么？不一样！别忘了他是被存储在内存的静态区中，所谓的静态区就是全局区，用来存放全局变量和静态变量的，程序不结束，这个区是不会被释放的，所以即使定义静态局部变量的函数结束，改静态局部变量仍然存在，下次访问改函数的时候，这个变量的值仍然是上次的值！举个例子把：

void foo(){
    static int i=0;
    i++;
    printf("%d\n",i);
}
int main(){
    foo();
    foo();
}

这个小例子的执行结果是什么呢？答案是：

1
2

对的，静态局部变量只能被初始化一次，并且值会被保留，使用这个有两个好处，一个是可以计算函数被调用的次数，一个是可以减少函数构建局部变量的开销，自己体会一下把。

(2)修饰函数： 经常见这种形式，但没怎么用过，也就没去想。其实这个作用跟静态全局变量相似，也是限定函数的作用域为本文件。这样作的好处就是不用操心是否会跟别人编写的文件里的函数重名。（我这里栽了一下，太弱了～不甘心阿！）

第四类：其他关键字

const
sizeof
typedef
volatile

下面，也是一样，一一解释下这些关键字：

1、const关键字： 这是一个很有意思的关键字，他修饰的变量是只读的，不能被修改；很多时候，编译器会将其优化成一个常量。const经常被用来修饰函数的参数，表示不希望这个参数值被函数体内的代码意外的改变。其实，最有意思的是用const修饰一个指针，让我们看下面这个例子：

const int *p;   //p可变，p指向的对象不可变
int const *p;   //同上
int *const p;   //p不可变，p指向的对象可变
const int *const p; //p和p指向的对象都不可变

这些各表示什么呢？注释里面给出了答案！是不是很不好记？我们只需要记得，const修饰的是*p的时候，p指向的内容不可变；const修饰的是p的时候，p就不可变！

2、sizeof关键字：很多人也许会大吃一斤，我类个去，sizeof居然是关键字？（高手请无视这里，我当初就是这种表现）。不错，sizeof确实是关键字，而不是库函数！所以，如果编译时得不到一个数组的大小，那么就不能使用sizeof关键字来获取改数组的大小！

3、typedef关键字： typedef说白了就是给一个已知的类型起一个外号。让我们考虑一个问题：

#define PCHAR char*
typedef char* pchar;

这两个语句都是给char*类型起一个别名，那么哪个比较好呢？ 要想知道答案，看下面：

PCHAR p1, p2;
pchar p3, p4;

看代码的意思，我们是想将p1,p2,p3,p4都赋成char*类型的，但是，事实是如此么？p2是么？

注意，p2并没有预期成为一个char*类型，因为define会在预编译阶段展开，所以语句1就相当于 char* p1, p2；而在这条语句下，p2不是一个指针，而是一个char类型的！这个错误经常会被忽略，所以一定要注意！

4、volatile关键字： 也许你见过这个关键字，但一般你都没有用过。哈哈，我用过！这个关键字表示改变量的值可能在外部被改变，编译器在用到这个变量时不能过度的优化，必须每次都重新从内存中读取这个变量的值，而不是将其优化在寄存器中。这个可以用来防止编译器优化产生的内存屏障，详细的看这里。

好吧，32个关键字介绍完了，我自恃很了解，也从中学了不少东西，但愿下次不要再犯这种低级的错误！没关系，一切都会好起来的！Success is going from failure to failure without losing enthusiasm！

参考书目：《C语言深度解剖:解开程序员面试笔试的秘密 》

言归正传，先解释下什么是内存屏障。内存屏障是指“由于编译器的优化和缓存的使用，导致对内存的写入操作不能及时的反应出来，也就是说当完成对内存的写入操作之后，读取出来的可能是旧的内容”（摘自《独辟蹊径品内核》）。（这里概念貌似不是很准确，正确的定义：为了防止编译器和硬件的不正确优化，使得对存储器的访问顺序（其实就是变量）和书写程序时的访问顺序不一致而提出的一种解决办法。 它不是一种错误的现象，而是一种对错误现象提出的解决方发－－－－欢迎指正！！）

概念就是概念，生硬的东西，懂的人能从中悟出点什么，不懂的人还是一头雾水。不要着急，我们先给内存屏障分下类，然后挨个来研究一番，等看完这篇文章，再回来读读概念，你就懂了！

内存屏障的分类：

1. 编译器引起的内存屏障
2. 缓存引起的内存屏障
3. 乱序执行引起的内存屏障

1、编译器引起的内存屏障：

我们都知道，从寄存器里面取一个数要比从内存中取快的多，所以有时候编译器为了编译出优化度更高的程序，就会把一些常用变量放到寄存器中，下次使用该变量的时候就直接从寄存器中取，而不再访问内存，这就出现了问题，当其他线程把内存中的值改变了怎么办？也许你会想，编译器怎么会那么笨，犯这种低级错误呢！是的，编译器没你想象的那么聪明！让我们看下面的代码：（代码摘自《独辟蹊径品内核》）

int flag=0;
 
void wait(){
    while ( flag == 0 )
        sleep(1000);
    ......
}
 
void wakeup(){
    flag=1;
}

这段代码表示一个线程在循环等待另一个线程修改flag。 Gcc等编译器在编译的时候发现，sleep()不会修改flag的值，所以，为了提高效率，它就会把某个寄存器分配给flag，于是编译后就生成了这样的伪汇编代码：

void wait(){
    movl  flag, %eax;
 
    while ( %eax == 0)
        sleep(1000);
}

这时，当wakeup函数修改了flag的值，wait函数还在傻乎乎的读寄存器的值而不知道其实flag已经改变了，线程就会死循环下去。由此可见，编译器的优化带来了相反的效果！

但是，你又不能说是让编译器放弃这种优化，因为在很多场合下，这种优化带来的性能是十分可观的！那我们该怎么办呢？有没有什么办法可以避免这种情况？答案必须是肯定的，我们可以使用关键字volatile来避免这种情况。

volatile int flag = 0;

这样，我们就能避免编译器把某个寄存器分配给flag了。

好，上面所描述这些，就叫做“编译器优化引起的内存屏障”，是不是懂了点什么？再回去看看概念？

2、缓存引起的内存屏障

好，既然寄存器能够引起这样的问题，那么缓存呢？我们都知道，CPU会把数据取到一个叫做cache的地方，然后下次取的时候直接访问cache，写入的时候，也先将值写入cache。

那么，先让我们考虑，在单核的情况下会不会出现问题呢？先想一下，单核情况下，除了CPU还会有什么会修改内存？对了，是外部设备的DMA！那么，DMA修改内存，会不会引起内存屏障的问题呢？答案是，在现在的体系结构中，不会。

当外部设备的DMA操作结束的时候，会有一种机制保证CPU知道他对应的缓存行已经失效了；而当CPU发动DMA操作时，在想外部设备发送启动命令前，需要把对应cache中的内容写回内存。在大多数RISC的架构中，这种机制是通过一写个特殊指令来实现的。在X86上，采用一种叫做总线监测技术的方法来实现。就是CPU和外部设备访问内存的时候都需要经过总线的仲裁，有一个专门的硬件模块用于记录cache中的内存区域，当外部设备对内存写入的时候，就通过这个硬件来判断下改内存区域是否在cache中，然后再进行相应的操作。

那么，什么时候才能产生cache引起的内存屏障呢？多CPU？ 是的，在多CPU的系统里面，每个CPU都有自己的cache，当同一个内存区域同时存在于两个CPU的cache中时，CPU1改变了自己cache中的值，但是CPU2却仍然在自己的cache中读取那个旧值，这种结果是不是很杯具呢？因为没有访存操作，总线也是没有办法监测的，这时候怎么办？

对阿，怎么办呢？我们需要在CPU2读取操作之前使自己的cache失效，x86下，很多指令能做到这点，如lock前缀的指令，cpuid, iret等。内核中使用了一些函数来完成这个功能：mb(), rmb(), wmb()。用的也是以上那些指令，感兴趣可以去看下内核代码。

3、乱序执行引起的内存屏障：

我们都知道，超标量处理器越来越流行，连龙芯都是四发射的。超标量实际上就是一个CPU拥有多条独立的流水线，一次可以发射多条指令，因此，很多允许指令的乱序执行，具体怎么个乱序方法，可以去看体系结构方面的书，这里只说内存屏障。

指令乱序执行了，就会出现问题，假设指令1给某个内存赋值，指令2从该内存取值用来运算。如果他们两个颠倒了，指令2先从内存中取值运算，是不是就错了？

对于这种情况，x86上专门提供了lfence，sfence,和mfence 指令来停止流水线：

lfence:停止相关流水线，知道lfence之前对内存进行的读取操作指令全部完成

sfence:停止相关流水线，知道lfence之前对内存进行的写入操作指令全部完成

mfence:停止相关流水线，知道lfence之前对内存进行的读写操作指令全部完成

好，将完这三种类型，再回去看看概念，清晰了么？如果还不明白，那就是我的表达能力太有限了，自己网上再搜搜把！

题目：

有一串首尾相连的珠子，共有m个，每一个珠子有一种颜色，并且颜色的总数不超过n(n<=10)，求连续的珠子的颜色总数为n时，长度最小的区间。可简述思路或者给出伪代码，并且给出时间和空间复杂度分析。（baidu 2011校园招聘笔试题目）

拿到这个题目，我首先想到的是暴力搜索。即对每个珠子，都搜索以该珠子为结尾的最短符合题意的序列。但是这样比较的时间复杂度特别高，应该是m的指数，显然是不可取的，通过简单的分析我们能够发现，在搜索过程中，我们进行了许多冗余的比较。本着空间换时间的想法，我们有没有办法把这些比较记录下来，然后去掉这些冗余呢？答案是肯定的。

我想到的一个算法，里面用到了一些动态规划的思想，可以在线性时间内完成题目。首先为了方便描述，让我们假设珠子不是首尾相连。让我们以数组a[m]来表示珠子的序列，用1-n数字来表示颜色，则算法思路如下：

1. 定义一个数组least[m]；对于a[i]的元素，least[i]表示珠子序列中以珠子a[i]为结尾的包含所有颜色的最短序列的长度；
2. 定义一个数组save[n+1]; 这个数组的元素save[i]表示颜色i上一次出现的位置，初始化为－1；注意这里的i表示颜色而不是珠子！
3. 定义一个数组next[m]；对于a[i]的元素，next[i]表示当前珠子的颜色下一次出现的位置；初始化为－1；
4. 定义两个指针 i 和 j ，初始化为0，即指向a[0]；
5. 首先遍历一遍a[m]，将每个珠子的颜色下一次出现的位置填充到next[i]中；具体做法是利用数组save[n+1]保存颜色c上一次出现的位置d，当再次出现c时，将next[d]设置为当前位置。这部分可以在O(m)时间内完成，具体代码中还可以优化。
6. 将指针j向右滑动
7. 判断 i<j 和 ( a[i]==a[j] 或者 next[i] < j ) 两个条件是否成立，如果不成立，least[j]=j-i+1 ，然后执行6；如果成立，i++，继续执行7。（ 判断a[i]==a[j]是因为如果a[i]==a[j]，则a[i]-a[j]之间的序列不够成最短序列；判断next[i]<j的因为在a[i]到a[j]之间存在颜色a[i]，因此a[i]也不应该被包括在最短序列里。）
8. 如果j = n，则遍历完成，找到least[m]中最小的数的位置，则就能找到符合题意的最小序列。

当然，我们需要考虑到珠子首尾相连。我们可以让j=n之后，从0开始重新循环，直到 i=n 或 j到达位置s，位置s表示从a[0]开始，第一个出现所有颜色的位置。

下面是我使用C语言实现的代码，在实际代码中，next[j]我是一边挪动 j 一边填充的。代码如下：

#include <stdio.h>
#define CNUMBER 4   //颜色的个数
int find(int *a, int n){
	int number = CNUMBER;  //定义一个计数器，目的是找到上面所说的第一个出现所有颜色的位置s
	int save[number+1];  //颜色上一次出现的位置
	int next[n];  //元素颜色下一次出现的位置 
	int least[n];  //以该元素结尾的最短序列
	int i, j;
	for(i=0;i<CNUMBER+1;i++){  //初始化
		save[i]=-1;
	}
	for(i=0;i<n;i++){  //初始化
		next[i]=-1;
	}
 
	i = 0;
	for(j=0;j<n;j++){
		if(number!=0)  
			least[j]=-1;  //将还没有出现所有颜色的位置的least设为－1，下面会用到
		if(save[a[j]]==-1){ //save[i]为-1表明该颜色i第一次出现
			save[a[j]]=j; 
			number--;
		}
		else{
			next[save[a[j]]]=j;  //设置next
			save[a[j]]=j;  //把save[i]设为当前位置，用于下一次使用
		}
		while(i<j){
			if(a[i]==a[j]||next[i]!=-1) //i++的条件
				i++;
			else
				break;
		}
		if(number == 0 )
			least[j]=j-i+1; //计算least
 
	}
 
	j=0;
 
	while(least[j]==-1 &&i<n ){ //这个循环的目的是为了满足首尾相接的条件而让j从头开始
		next[save[a[j]]]=j;
 
		while(i<n){
			if(a[i]==a[j]||(next[i]>i||next[i]<j)&&next[i]!=-1)
                        //next[i]>i||next[i]<j 表示a[i]表示的颜色下次出现在i和j之间
				i++;
			else
				break;
		}
 
		least[j]=j+n-i+1;
 
		j++;
	}
 
	for(i=0;i<n;i++)
		printf("%d ", least[i]); //我这里最终将所有least打印出来，可以更改下让把符合题意的序列打印出来
	printf("\n");
 
}
 
int main(){
	int n;
	int a[100];
	scanf("%d", &n); //n表示珠子的长度
	int i;
	for(i=0;i<n;i++)
		scanf("%d", &a[i]); //输入珠子
	find(a, n);
}

当然，这个算法未必就是一个很好的算法，如果你有更好的方法，欢迎留言讨论。

struct node{
    int a;
    int b;
};

问：sizeof(Node)是多少？ 答案很简单，在32位机器上，一个int是4个字节，两个int就是8个字节，sizeof(Node)就是8。

好的，上面那个答案确实是8，那么再看下面这个结构体：

struct node{
    char a;
    int b;
};

问：这个时候sizeof(Node)又是多少呢？ int是4个字节，char是1个字节，答案是5？

这回，没有那么幸运，经过在机器上的操作，答案是8！ Why？

实际上，这不是语言的问题，你在ANSI C中找不到为什么会这样！甚至你在不同的体系结构、不同的编译器下会得到不同的答案。那么，到底是谁把5改成了8呢？

这就引入了一个概念，叫做“内存对齐”。所谓的内存对齐，是指一种计算机体系结构（如X86）对基本数据类型的存储位置有限制，要求其地址为某个数的倍数，通常这个数为4或8。这种要求会简化处理器的设计以及提升数据访问的效率。至于为什么会有这样的设计，简单的说访存总线的位数固定，以32位总线为例，地址总线的地址总是4对齐的，所以数据也四对齐的话，一个周期内就可以把数据读出。这里不理解的话可以跳过去，只要记得对齐这回事儿就行了。如果想更深入的理解，可以看这里另一篇文章。

知道这个之后，那么我们就可以理解，实际上是编译器为了效率，在相邻的变量之间放置了一些填充字节来保证数据的对齐。X86结构是4对齐的，所以sizeof(Node)是8不是5。

再来看一个例子：

struct node{
    int a;
    char b;
    char c;
    int d;
    char d;
};

这时的sizeof(Node)是多少呢？没错，是16。

好的，既然我们知道对齐是由编译器来作的，那么我们可不可以更改对齐数呢？ 答案是可以的，在C语言中，我们可以通过

#pragma pack(n)

来更改对齐模数。

注：以上都是在现x86 linux下使用gcc编译器验证，不乏有其他系统和编译器会得到不同的结果。

再让我们来看个例子：

        struct node {
                double a;
                int b;
                int c;
                char d;
        };

这个时候的sizeof(node)是多少？20？24？

其实，这个时候你会发现，当你在windows上使用VC编译的时候，你会得到24；当你在linux上使用gcc编译的时候，你会得到20！其实，这恰好说明这种数据的对齐是由编译器决定的！在VC中规定， 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；而在gcc中规定对齐模数最大只能是4，也就是说，即使结构体中有double类型，对齐模数还是4，所以数据是按照1，2，4对齐的。所以，在两个不同编译器上，你得到了不同的答案！

要求：

1. 所有的4均不会出现在排列的第4个位置
2. 数字3和数字5不能相邻
3. 排列不能重复。

实现思想：

采用回朔的方法便利所有可能的排列，其中把不符合题目要求的去除。需要额外注意的是，数字中出现了两个2，如果单纯的遍历，会打印两次2在某个位置的排列，要注意把这个重复给去除。

C语言代码实现如下：

#include<stdlib.h>
#include<stdio.h>
 
int a[6]={1, 2, 2, 3, 4, 5 }; 
int b[6]; //用来存放排列好的序列
int pointer; //回朔指针
int total; //总的排列个数
int range(){
	int i;
	if(pointer == 6){
		printf("total:%d, range: %d %d %d %d %d %d \n", 
		++total, b[0], b[1], b[2], b[3], b[4], b[5]);
	}
	for(i=0; i<6; i++){
		if(a[i] == 0)
			continue;
 
		if(a[1]!=0 && i==2)
			continue; //防止重复使用2
 
		if(pointer>0 && (b[pointer-1]==3 && a[i] == 5 
		   || b[pointer-1]==5 && a[i]==3)) //防止3,5相邻
			continue;
 
		if(pointer == 3 && a[i]==4)
			continue; //防止数字4出现在位置4
 
		b[pointer] = a[i];
		pointer ++;
		a[i] = 0; //使用过的数字给设置成0，防止重复使用
		range();
		pointer --;
		a[i] = b[pointer];		
	}
}
 
int main(){
	range();
	return 0;	
}

这个题目是sohu2011笔试题，题目并不难，关键是细节要考律全面，如要去除因为两个2而导致的重复序列。
我在笔试卷子上写的乱七八糟，而一在电脑上立马就写出来了，果然还是很不擅长笔试阿！