先介绍一下这首背景音乐吧，老早就听过，前几天才发现出处：是“Merry Christmas Mr. Lawrence”这部电影（断臂片）的主题曲，也是坂本龙一配乐的处女作。这个版本是押尾光太郎的指弹吉他版。

自从开始实习就没有更新过blog了，加上软工、数据库、图形学乱七八糟的实验，有点忙不过来了。

本来一直在想以后做Linux相关的开发，周围认识的很多学长都走上了这条路，开始实习后却事与愿违搞起了Linux开发。其实说实话一直也不知道自己的兴趣点在哪里，工作了一个月后感觉可能还是桌面和互联网更适合自己，对于系统开发、运维这样的工作，干长时间可能会受不了……纠结啊

前两天和朋友聊到windows下一个程序如何删除自己，正好以前和同学讨论过这个问题，写出来凑个数。

其实真正的删除自己肯定是做不到的，至少用户态不行。windows下只要一个文件被某个进程打开就不能被删掉（Linux下可以删除任何打开的文件，只要有权限，而且一般不会影响程序的执行，因为文件系统会等到所有的打开的fd都释放后会才回收inode和data）,所以一个windows进程在运行的时候是肯定不可以删除自己的可执行文件的，只能想一些旁门左道了。

Solution

方法其实很简单，就是在程序结束前开另一个进程去删自己，但是要求是自己删自己，所以只能借助系统utils。这时候就需要bat脚本来帮忙了。在CMD下删除一个文件很容易，一条del命令就搞定了，但是需要保证执行脚本的时候原进程已经结束运行了，一般来说用一条延时命令walk around“ping 127.0.0.1 -n 2”，2为秒数，然后用“&”连接del命令删除文件

ping 127.0.0.1 -n 2 >nul && del path/to/your/file.exe

更为保险的做法是在bat里用tasklist命令查看进程，循环直到找不到当前进程位置

原来的和同学讨论的是一个程序如何自己修改自己，做到单文件自动更新，实际上和自己删除自己是一个问题。无非就是先生成一个自身的副本，修改副本，再程序结束后用bat脚本覆盖自己就ok了，源代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <windows.h>
#include <stdio.h>
 
int main(int argc, char * argv[])
{
    char self[_MAX_PATH];  
    char swap[_MAX_PATH];
 
    // get the full path of myself
    GetModuleFileName(NULL, self, _MAX_PATH);
 
    // copy myself to a temp file for modify 
    strcpy(swap, self);
    strcat(swap, ".tmp"); // add .tmp postfix. better to use tempnam()
    CopyFile(self, swap, FALSE); 
 
    FILE * fp = fopen(swap, "ab");
    // pending whatever you want to the exe
    fwrite("Hack is not good, but i love it.", 32, 1, fp);
    fclose(fp);
 
    // "ping" is used for delay to wait the main process terminated.
    // "move /Y src dst" : overide whtout warnning
    // quotation marks are needed for paths which contain blank.
    char bat[2*_MAX_PATH + 30] = "cmd /c ping 127.0.0.1 -n 2 >nul && move /Y \"";
    strcat(bat, swap);
    strcat(bat, "\"");
    strcat(bat, " \"");
    strcat(bat, self);
    strcat(bat, "\"");  // bat += "path\to\swap" "path\to\self" 
 
    WinExec(bat, SW_HIDE); // Exec the bat script with window hiden
 
    return 0;
}

C库函数和win32 API混用，看着挺别扭，本来写的时候还想尝试一下匈牙利，被恶心到以后还是放弃了，还好用到的API都参数比较简单，自从大一的时候看到一个win32 API调用占了半屏后，对win32 API就深为恐惧，再加上满屏幕的大写，读起来简直就是噩梦…

Improvement

用ping命令延时只是一个walk around，在系统负载很重的情况下，2秒程序也未必退出了，所以应该寻找一个方法确定一个exe是否在运行。小研究了一下bat，发现通过tasklist命令和find命令可以搞定：

:loop
tasklist /NH | find /i "xxx.exe"
if %ERRORLEVEL% equ 1 (
goto loop
) else (
del path\to\your\file\xxx.exe
)
exit

ERRORLEVEL变量是上一条命令的返回值，不停的在进程列表里寻找xxx.exe直到找不到为止。

顺便bless一下灾区的同胞们还有但愿今天可以拿到工资….

Related Post

• No Related Post

1.IO重定向功能分析

IO重定向也是Shell的基本功能之一，这篇文章比较全面地介绍了Linux Shell的IO重定向功能。总结一下，IO重定向的大致格式是这样：

cmd  [src | &]     (> | < | >> )      (& num|-)  | dst

貌似写得有点复杂（我不是故意的）。解释一下，整个重定向语句由三部分组成：

第一部分（[src|&]）：src代表被重定向的文件描述符，一般是0（stdin）、1（stdout）和2（stderr），此外还可以是‘＆’，代表2和3，也就是把stdout和stderr同时重定向。这一部分通常是省略的，‘>’和‘>>’隐含了0，‘<’隐含了1，也就是说

$ cmd <file 等价于
$ cmd 0<file
$ cmd >file 等价于
$ cmd 1>file

第二部分（> | < | >>）：三种操作符。‘<’将src的输入重定向到目标文件；‘>’将src的输出重定向到目标文件（若文件不存在则创建，否则现有文件被截断(truncation)）；‘>>’将src的输出附加到（pending）目标文件尾部（若文件不存在则创建）。

第三部分（ (& num|-) | dst ）：第三部分有两种形式，最常见的就是一个文件名，代表重定向的目标。此外还可以是’&'加一个数字，代表将src重定向到数字代表的文件描述符上。另外‘&’后还可以接‘-’，代表关闭src。比如：

$ cmd 2>&1     将标准错误重定向到标准输出
$ cmd 1>&-      关闭标准输出
$ cmd 0<&-      关闭标准输入

2.IO重定向功能实现

Linux的IO重定向实际上是通过dup函数和close函数配合实现。close关闭一个文件描述符，而dup复制一个文件描述符，并且新产生的文件描述符是当前可用文件描述符的最小值。

通过先将要重定向的fd关闭，在将重定向的目标文件的描述符dup就实现了重定向（因为012三个描述符默认都是打开的，关闭任何一个后其都将成为当前可用的最小文件描述符）。

为了支持重定向命令的分析，实现里新添加了一个结构，记录了每个重定向的必须信息，然后在子进程fork以后根据记录信息进行重定向操作。

测试的时候发现了一个有趣的问题。比如：

$ ls >f1 >f2
$ cat >f1 >f2

这两条命令在bash里的结果是后面的重定向覆盖了前面的重定向，这和我的实现是一样的，也是最简单的。而在zsh里，第一条命令的结果是f1 f2文件有相同的内容，也就是标准输出同时被重定向到f1和f2两个文件里了；第二条命令的效果等同于先把f1、f2两个文件现连接起来再重定向到cat的输入。这是相当神奇的，到现在也没找到实现方法，看来得找时间研究一下zsh的代码了。

其实实现重定向最麻烦的地方是命令分析，也就是字符串处理。parse_command函数俨然已经100行了，两个switch-case加无数个if-else组成的大自动机，不加注释恐怕就是write-only了（感觉加了注释还是write-only）…

打开重定向文件那里有一点问题，一大堆flags或来或去，最傻的是忘了给创建的文件设置mode，结果只能用root权限查看…

源代码 : jdsh_v3.h jdsh_v3.c（为了让乱七八糟的代码稍微可读一点，单独分了个头文件出来）

剩下的任务就是管道了，有必要把代码好好整理一下了。

Related Post

• 自己动手写Linux Shell（二） —— 支持后台执行 (2)
• 自己动手写Linux Shell（一） —— 简单的命令解释器 (2)
• 我和Linux (0)
• 在Archlinux上的安装Tor (6)

本来以为加入后台执行不是什么难事，但是认真想了一下要处理好一个字符‘＆’不是一般的麻烦，各种问题接踵而至，于是决定先找点轻松的活干。

1.加入shell内建命令

每个shell都有自己的内建命令，最常见的有“cd”、“pwd”、“exit”等等。没有“cd“的shell是没法干活的。

其实很简单，标准的做法建个hash表把所有内建命令加进去，parse command以后先查一下表就行了，然后可以通过像Linux Syscall的实现方法一样，用一个字符串连接宏（##）找到对应的处理函数。但是由于只准备写寥寥几个命令，偷懒直接 if else if了（= =!）。

2.打印命令提示符Prompt

每个命令行shell都有命令提示符，告诉用户现在可以敲命令。大多数的linux shell的prompt是可以定制的。我采用了bash的默认格式“[username@hostname cwd]$ ”。实现prompt里的cwd（current working directory）时候发现了一个问题：基本上所有linux shell里都用了’~'代替$HOME。于是做个个字符串替换，使得home文件夹在显示的时候都显示为’~'（命令里的路径还不支持’~'）

3.处理SIGINT、SIGQUIT和SIGTSTP信号

SIGINT信号对应按下ctrl+c，shell对该信号的处理方式是（观察zsh/bash得到，没有查文档）：若shell当前没有前台任务，则输入一个空行，放弃当前正在输入的命令；若当前有前台任务，则SIGINT信号由前台程序捕捉。

SIGQUIT信号对应按下ctrl+\，shell对该信号的处理方式是（观察zsh/bash得到，没有查文档）：若shell当前没有前台任务，则忽略该信号，放弃当前正在输入的命令；若当前有前台任务，则SIGQUIT信号由前台程序捕捉。

SIGQUIT信号对应按下ctrl+z，shell对该信号的处理方式是（观察zsh/bash得到，没有查文档）：若shell当前没有前台任务，则忽略该信号，放弃当前正在输入的命令；若当前有前台任务，则SIGQUIT信号由前台程序捕捉。
PS:对这APUE里的信号表看了一遍，好像没有其他要特殊处理的信号了。

其实很好处理，用signal函数或者sigaction都可以（偷懒就用signal了）。在shell的主进程里改变SIGINT的信号处理函数、忽略SIGQUIT和SIGTSPT信号就可以。

有一个问题需要注意：必须在fork的子进程里恢复对这几个信号的默认处理方式。因为fork产生子进程和父进程有相同的信号处理函数signal handler。解决方法就是fork以后在子进程里手动恢复修改过的信号。另一种方法是不用fork，改用clone系统调用，通过clone flags里的CLONE_SIGHAND参数使得复制出来的进程不保留父进程的信号处理函数。

回到主题上…..

4.后台运行程序

其实单纯的实现后台运行很简单，把前面程序里的wait去掉使shell主进程不等待子进程结束就OK了。问题在于，shell是通过一个’&'字符决定后台执行，如何才能从命令里提取出这个代表后台执行的’&'字符？

看起来似乎一个字符串查找就能解决，其实并非如此：如果这’&'是在一个路径名里呢(Linux中只有一个字符不能做文件名：’/')。看一下别的shell很快就会找到解决方法：转义字符。如果想把有特殊含义的字符当作一个普通字符处理，那么就要在前面加上转移字符’\'（比如空格、’\'、’&'、’~'、’-'等等）。

要支持转移字符，我原来用strsep实现的优美的parse command函数就得全部扔掉重写。没办法，换成了fgetc和丑陋的switch case。

有了转义字符，就可以处理含有特殊字符的文件名了^ ^

另外，我观察到bash和zsh在后台程序运行结束后都会显示一条提示信息显示pid和命令，于是我也想把这个功能加进去。思路很简单，就是改变SIGCHLD信号的handler，捕捉到SIGCHLD后输出进程信息就可以了。默认SIGCHLD信号是通过wait和waitpid函数捕捉。signal能改变SIGCHLD信号的处理函数，但是无法获得足够的信息（pid、退出代码等），而sigaction支持复杂的信号处理函数，通过向信号处理函数传递siginfo结构，提供更充足的信息（还是sigaction强大）。

差不多就这样了…代码量翻了一倍，直接贴出来有点恐怖，所以扔到附件了～（BUG很多，就不一一列举了，sign～）

源代码：jdsh_v2.c

Related Post

• 自己动手写Linux Shell（三） —— 支持IO重定向 (1)
• 自己动手写Linux Shell（一） —— 简单的命令解释器 (2)
• 我和Linux (0)
• 在Archlinux上的安装Tor (6)

寒假在做Linux Kernel Project这本书上的习题，第二章的练习是写一个简单的shell，看了一下要求觉得这个练习很有价值，涉及到很多Linux C Programming的知识，所以准备认真地做一下。

最终的目标如下:
1. 命令解释执行
2. 支持后台执行(&)
3. 支持输入输出重定向(<, >, >>)
4. 支持管道IPC
5. 内建命令cd, pwd, exit等

可见写一个shell并不是一件简单的事，从简单的一步一步做起吧，手头有APUE，一边做一边查。

一个简单的命令解释器

命令解释执行是shell最基本的功能，实现的方法很简单：从标准输入流中读入命令，然后exec一下就行了。但是还有很多琐碎的地方需要处理：

1.命令行参数传递

首先需要将输入的命令字符串按空格打断（strsep实在是太方便了），然后将打断的字符串构建成一个char*数组，通过execv的第二个参数传递给程序。

注：man exec可以得到关于exec函数族的详细说明。需要说明的是execlp和execvp会在PATH环境变量中的目录搜索可执行程序，而其他的exec函数族函数不会，如果不使用这两个函数，则需要自己编写代码搜索PATH环境变量。

2.使用fork建立子进程

直接在当前进程里exec的话，exec执行的程序结束后，整个程序也就结束了，因为exec直接将原来的进程上下文替换。所以需要fork一个新进程来执行命令，而父进程阻塞直到子进程结束后继续执行，这个可以通过wait函数实现。

3.处理命令的返回值

大多数的shell在命令程序返回非零值（异常退出）会打印出其返回值。而子进程的返回值可以在父进程里通过wait函数的第一个参数得到。然后通过一组宏可以方便地确定子进程的返回状态。这部分内容在APUE里有详细说明（8.6节），下面代码里的pr_exit函数基本上就是从APUE上抄过来的。

4.检查各个函数的返回值

Linux C Programming的一个原则就是在所有可能fail的地方加入检查代码。绝大多数C库函数和Linux系统函数都以负数返回值表示出错，并且通过C库的全局变量errno可以获得错误号，从而得到错误原因，并输出到标准错误流。由于整个过程动作固定，就用一个CHKERR宏来完成了。

下面是源代码

CODE BELOW ARE UNDER GPLV3 LISENCE

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

/* By JackalDire, Jan 29 2010 
 * Tested on Linux Kernel 2.6.32, gcc 4.4.3 */
#include <unistd.h>
#include <sys/wait.h>
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
 
#define LINE_MAX 8192
#define ARG_MAX 1024
#define ARG_NR_MAX 32
 
#define CHKERR(ret, msg) if (ret < 0) {\
        fprintf(stderr, "ERROR : \"%s\", %s\n", \
                msg, strerror(errno)); \
        exit(-1);   \
    } 
 
char * args[ARG_NR_MAX + 1];
extern char ** environ;
 
char line[LINE_MAX + 1];
 
void parse_command(char * cmd)
{
    char * res;
    size_t cnt = 0;
    /* tokenize the command string by space */
    while ((res = strsep(&cmd, " ")) != NULL) {
        printf("%s\n", res);
        args[cnt++] = strdup(res);
    }
    args[cnt] = NULL;
}
 
void pr_exit(const char * name, int status)
{
    if (WIFEXITED(status)) // exit normally
        return;
    else if (WIFSIGNALED(status))
        fprintf(stderr, "%s exit abnormally, signal %d caught%s.\n",
                name, WTERMSIG(status),
#ifdef WCOREDUMP
            WCOREDUMP(status) ? " (core file generated)" : "");
#else
            "");
#endif
    else if (WIFSTOPPED(status))
        fprintf(stderr, "child stopped, signal %d caught.",
                WSTOPSIG(status));
}
 
int main(int argc, char * argv[])
{
    char c;
    size_t idx;
    int r;
    int status;
 
    while (1) {
        idx = 0;
        bzero(line, LINE_MAX + 1);
 
        c = fgetc(stdin);
        while (c && c != '\n') {
            line[idx++] = c;
            c = fgetc(stdin);
        }
 
        parse_command(line);
        r = fork(); 
        CHKERR(r, "fork");
        if (r == 0){
            r = execvp(args[0], args);
            //printf("ret : %d\n", r);
            CHKERR(r, args[0]);
        } else {
            wait(&status);
            pr_exit(args[0], status);
        }
    }
    return 0;
}

一个简单的命令解释器就这样完成了，下面的工作就是添加后台执行功能，休息一会^ ^

Related Post

• 自己动手写Linux Shell（二） —— 支持后台执行 (2)
• 自己动手写Linux Shell（三） —— 支持IO重定向 (1)
• 我和Linux (0)
• 在Archlinux上的安装Tor (6)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

result love(boy, girl) 
{ 
    if ( boy.有房() and boy.有车() ) { 
        boy.set(nothing); 
        return girl.嫁给(boy); 
    } else if (girl.愿意等()) { 
        while( ! (boy.赚钱 ＞ 1e6 and girl.感情 ＞ 8 )) { 
            for (day=1; day ＜=365; day++) { 
                if ( day == 情人节 ) 
                    if ( boy.givegirl(玫瑰) ) girl.感情++; 
                    else girl.感情--; 
                if( day == girl.生日) 
                    if ( boy.givegirl(玫瑰) ) 
                        girl.感情++; 
                else girl.感情--; 
                boy.拼命赚钱();
                if( girl.耐心 == 0 && girl.有其它追求者) { 
                    girl.goto(nother_boy); 
                    boy.郁闷中(); 
                    boy.天天到BYR灌水(); 
                    return 没有结果; 
                } 
            } 
        }
        try 
        { 
            girl.要男友买房(); 
            girl.要男友买车(); 
            girl.每天逛专卖店(); 
            if ( boy.有房() && boy.有车() ) { 
                girl.去澳洲旅游(boy); 
                girl.到英国威斯敏斯结婚(boy); 
                girl.嫁给(boy); 
                boy.没日没夜挣钱(); 
            } 
        } catch() { 
            girl.byebye(boy); 
            boy.郁闷中(); 
            boy.天天到天涯灌水(); 
            return girl.broadcast("这个男人真小气"); 
        } 
        return girl.每天逛专卖店(); 
    } 
    return girl.goto(another_boy); 
}

Version 2 (By wks)

1
2
3
4
5
6
7
8
9
10

void love(Man &m, Woman &w) { 
     try { 
         while(w.isFuckable()) { 
         doSomething(things[rand()%((sizeof(things))/(sizeof(things[0])))]); 
         wait(); 
        } 
    } catch (CanWaitNoLongerException e) { 
    } 
    m.fuck(w); 
}

Version 3 (By me)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

void Man::love() { 
    try { 
        while(m.alive() && (!m.hasHouse() || !m.hasCar())) { 
            m.makeMoney();  // good luck if this is not a infinite loop... 
        } 
        Woman w *; 
        while(w = findMM())  // good luck if this do not block forever... 
        { 
            if (w->isLove(*this) && w->getParents().isLike(*this) 
                && w->getParents().getParents().isLike(*this) 
                && ...)    
                marry(w); 
            else continue; 
        } 
    } catch (房子又涨价了Exception  & e) { 
        letItBe(); 
    } catch (遇到宋思明了Exception  & e) {  
        letItBe(); 
    } catch (被炒鱿鱼了Exception & e) { 
        letItBe(); 
    } catch (家命难违Exception & e) { 
        letItBe(); 
    ...... 
    } finally { 
        mayGodSaveMe(); 
    } 
}

Related Post

• No Related Post

为了尽快阻止这个连续N天没有日志的记录，先找一篇凑数…

先上开胃小菜 Appetizer

有人在byr论坛C++版上问了这样一道C++面试题：

class A {
    public: void fun()    {    }
};
 
class B: public A {
    public: virtual void fun() {    }
};
 
class C: public B {
    public: void fun(){}
};
 
class D: virtual public A {
public:
    void fun(){}
};
 
int main(void)  {
    void *p;
    ((A*)NULL)->fun();
    ((C*)NULL)->fun(); // why fault here?
    ((D*)NULL)->fun();
    return 0;
}

为什么在((C*)NULL)->fun()这句挂了呢？

原因很简单：B的fun是虚函数, 而C继承B, 所以通过C对象指针调用fun的时候触发基类virtual方法的多态特性, 需要查通过vptr查询虚表, 但是对NULL强制类型转换并不会设置vptr（vptr的设置是在构造函数中完成的），编译器就把地址0（NULL）中的内容当vptr，一解引用就segment fault了。

其实一开始看((A*)NULL)->fun();这句也觉得别扭，没有构造对象就直接调用非static的成员方法，居然还没有运行错误。想了一想，实际上在编译期，编译器都会通过一个name mangling机制将类的成员函数转换成一个具有唯一名字的非成员函数。程序开始运行时，成员函数和非成员函数一样都被载入到内存。所以只要在调用的成员函数不用到需要由类构造函数构造的成分（比如成员变量和vptr），这种通过指针调用成员函数就不会出错。

其实这个问题并不复杂，但是jmpesp老兄在回帖中写了一道更恶心的题目。

主菜来了 Main Dishes

class A {  
public:  
    virtual void fun(float) { cout << "A"; }  
};  
 
class B {  
public:  
    virtual void fun(int) { cout << "B"; }  
};  
 
class C: public B, public A {  
public:  
    void fun(float) { cout << "C float"; }
    void fun(int)   { cout << "C int"; }
}; 
 
int main(void) {       
    C* p = new C;
    ((B*)(A*)p)->fun(1);
    delete p;
    return 0;
}

问该段代码的输出是什么？

自己编译运行了一下输出是：C float…

首先输出C是确定的，因为无论怎么转型， p都是指向一个C对象，而A、B中的fun都是虚函数，所以调用的肯定是C类方法。输出float看起来比较诡异，原因肯定在这个(B*)(A*)c-style转型上。

     cout << (A*)p << endl;
     cout << (B*)p << endl;
     cout << (B*)(A*)p << endl;

上面的代码得到以下输出：
00382E30
00382E34
00382E30

可见(B*)(A*)p和(A*)p是相同的。

分析如下：

C继承了A和B，所以一个C对象里包含了一个A对象和B对象。由上面的输出知道(A*)p使得p偏移到了C对象中的A对象，是个static_cast。 接下来(B*)再对指向A对象的p进行转型，这时候问题就出现了，B对象并不包含A对象，编译器也不知道p指向的A对象实际上是包含在一个C对象里，所以 (B*)这次转换，只是改变了p的静态类型，并没有改变p指向的位置，是个reinterpret_cast也就是说p还是指向一个A对象。所以通过p调用fun(1)的时候，查的是A的虚表，先查到virtual void A::fun(float)，再到void C::fun(float)

这个问题的关键就在(B*)(A*)p这两个C-Style的函数式转型(functional cast)上:
(A*)p是从派生类C到基类A的转换，有可能是个向从派生类到基类的static_cast，也有可能是个简单的reinterpret_cast, 从运行结果上看(A*)是个static_cast，而由(A*)到(B*)的转换不可能是static_cast（static_cast (static_cast(p)))是编译不过的），所以只能是reinterpret_cast

这里又出现了一个问题，为什么(A*)p是个static_cast而不是reinterpret_cast？至少这与我的直觉不服，在ISO C++标准5.4节找到如下定义(见图):

也就是说一个C-style的强制类型转换如果可以解释成多个列表里的C++ style转型，取在列表里位置最前面的一个。static_cast在reinterpret_cast前，所以得到了下面的结果：

(B*)(A*)p 等价于 reinterpret_cast(static_cast(p))

由这道题目说明（Conclusion）：

1. 千万不要用C-style对对象指针进行转型，请用C++-style的static_cast、reinterpret_cast和dynamic_cast，以免造成意料之外的错误。
2. C++标准是个好东西，它胜过任何技术手册，一旦对语言特性有困惑，查标准是最好的解决方法。

Related Post

• 类继承的开销 ——《Inside the C++ Object Model》笔记二 (0)
• 构造函数 ——《Inside the C++ Object Model》笔记一 (0)

字符串1：只含有英文字母
字符串2：含有英文字母和*，其中符号*表示匹配任意字符0或者多次，即正则表达式里面的含义。

现在给定这样的两个串，要求判断是否匹配？
bool isMatch ( const char *str1, const char *str2)

例如：str1 = “hello”, str2 = “he*o”，则二者匹配，返回true,str1 = “hello”, str2 = “he*l”，则不匹配，返回false。

Solution

关键是如何处理*，首先想到的就是回溯，在纸上画了一下得到如下算法

设输入是两个字符串 s, t, 其中t可能包含* <.p>
1.当*t不是*的时候, 就像普通的串匹配一样, 移动s和t
2.当*t是*的时候, 假设*t后面第一个不是*的字符是x, 若x是null, 直接匹配成功, 否则在s中找到当前位置后所有字符x的位置, 这时候问题转化成了t中x后的串和s中当前位置以后所有以x为开始的串的匹配问题, 递归调用即可, 其中任意一个匹配成功, 则原串匹配成功, 若都没有匹配成功则匹配失败.

3.当*s和*t其中一个是null时 跳出循环, 若此时 *t == ‘*’, 则++t 知道 t != ‘*’, 这时若 *t == 0 则代表匹配成功, 否则匹配失败。

代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

#include <cstring>
#include <iostream>
 
using namespace std;
 
bool is_match(const char * s, const char * t)
{
    while (*s && *t)
    {
        if (*t != '*' && *s == *t)
            ++s, ++t;
        else if (*t != '*' && *s != *t)
            return false;
        else if (*t == '*')
        {
            do ++t; while (*t == '*');
            if (*t == 0) return true;
            for ( ; *s; ++s)
                if (*s == *t && is_match(s+1, t+1))
                    return true;
            return false;
        }
    }
    while (*t == '*') ++t;
    if (*s == *t) return true;
    else return false;
}
 
int main(int argc, char * argv[])
{
    if (is_match(argv[1], argv[2]))
        cout << "match" << endl;
    else cout << "not match" << endl;
    return 0;
}

改进

上面的暴力算法如果遇到“aaaaaaaaaaaaaaaa”，“a*a*a*a*a*a*a*a*a*a*a*a”这样的输入，会达到2^n的复杂度，是无法接受的。注意到，递归搜索是有很多重复的状态，自然就想到了记忆化搜索，时间空间复杂度均为O(n^2)，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

#include <iostream>
#include <cstring>
using namespace std;
const int MAX_LEN = 1024;
int dp[MAX_LEN][MAX_LEN];
 
bool is_match(int p, int q, const char * s, const char * t)
{
    if (dp[p][q] >= 0) return dp[p][q];
 
    int &ans = dp[p][q] = 0;
 
    if (!s[p] && !t[q]) {
        ans = true;
    } else if (!s[p] || !t[q]) {
        if (t[q] == '*') {
            ans = is_match(p, q + 1, s, t);
        }
    } else {
        if (t[q] == '*') {
            ans = is_match(p + 1, q, s, t)
                || is_match(p, q + 1, s, t);
        } else if (s[p] == t[q]) {
            ans = is_match(p + 1, q + 1, s, t);
        }
    }
    return ans;
}
 
bool is_match(const char * s, const char * t)
{
    memset(dp, -1, sizeof(dp));
    return is_match(0, 0, s, t);
}  
 
int main(int argc, char * argv[])
{
    if (is_match(argv[1], argv[2]))
        cout << "match" << endl;
    else cout << "not match" << endl;
    return 0;
}

Related Post

• 快速排序详细分析 (4)
• [备忘]倒置字符串中的单词 (0)
• Fibonacci数的巧妙求法 (2)

注：REF[n]为参考资料，列于文章结尾。

看了编程珠玑Programming Perls第11章关于快速排序的讨论，发现自己长年用库函数，已经忘了快排怎么写。于是整理下思路和资料，把至今所了解的快排的方方面面记录与此。

纲要

1. 算法描述
2. 时间复杂度分析
3. 具体实现细节
1. 划分
1. 选取枢纽元
1. 固定位置
2. 随机选取
3. 三数取中
2. 分割
1. 单向扫描
2. 双向扫描
3. Hoare的双向扫描
4. 改进的双向扫描
5. 双向扫描的其他问题
2. 分治
1. 尾递归
4. 参考文献

一、算法描述（Algorithm Description）

快速排序由C.A.R.Hoare于1962年提出，算法相当简单精炼，基本策略是随机分治。
首先选取一个枢纽元（pivot），然后将数据划分成左右两部分，左边的大于（或等于）枢纽元，右边的小于(或等于枢纽元)，最后递归处理左右两部分。
分治算法一般分成三个部分：分解、解决以及合并。快排是就地排序，所以就不需要合并了。只需要划分（partition）和解决（递归）两个步骤。因为划分的结果决定递归的位置，所以Partition是整个算法的核心。

对数组S排序的形式化的描述如下（REF[1]）:

1. 如果S中的元素个数是0或1，则返回
2. 取S中任意一元素v，称之为枢纽元
3. 将S-{v}（S中其余元素），划分成两个不相交的集合：S1={x∈S-{v}|x<=v} 和 S2={x∈S-{v}|x>=v}
4. 返回{quicksort(S1) , v , quicksort(S2)}

二、时间复杂度分析（Time Complexity）

快速排序最佳运行时间O(nlogn)，最坏运行时间Ｏ(N^2)，随机化以后期望运行时间O(nlogn)，关于这些任何一本算法数据结构书上都有证明，就不写在这了，一下两点很重要：

1. 选取枢纽元的不同, 决定了快排算法时间复杂度的数量级；
2. 划分方法的划分方法总是O(n), 所以其具体实现的不同只影响算法时间复杂度的系数。

所以诉时间复杂度的分析都是围绕枢纽元的位置展开讨论的。

三、具体实现细节（Details of Implementaion）

1、划分(Partirion)

为了方便讨论，将Partition从QuickSort函数里提出来，就像算法导论里一样。实际实现时我更倾向于合并在一起，就一个函数，减少了函数调用次数。（REF[2]）

1
2
3
4
5
6
7
8
9

void QuickSort(T A[], int p, int q)
{
    if (p < q)
    {
        int q = Partition(A, p, q);
        QuickSort(A, p, q-1);
        QuickSort(A, q+1, r);
    }
}

划分又分成两个步骤：选取枢纽元和按枢纽元将数组分成左右两部分

a.选取枢纽元（Pivot Selection）

固定位置

同样是为了方便，将选取枢纽元单独提出来成一个函数：select_pivot(T A[], int p, int q)，该函数从A[p...q]中选取一个枢纽元并返回，且枢纽元放置在左端（A[p]的位置）。

对于完全随机的数据，枢纽元的选取不是很重要，往往直接取左端的元素作为枢纽元。

1
2
3
4

int select_pivot(T A[], int p, int q)
{
    return A[p];
}

但是实际应用中，数据往往是部分有序的，如果仍用两端的元素最为枢纽元，则会产生很不好的划分，使算法退化成O(n^2)。所以要采用一些手段避免这种情况，我知道的有“随机选取法”和“三数取中法”。

随机选取

顾名思义就是从A[p...q]中随机选择一个枢纽元，这个用库函数可以很容易实现

1
2
3
4
5
6

int select_pivot_random(T A[], int p, int q)
{
    int i = randInt(p, q);
    swap(A[p], A[i]);
    return A[p];
}

其中randInt(p, q)随机返回[p, q]中的一个数，C/C++里可由stdlib.h中的rand函数模拟。

三数取中

即取三个元素的中间数作为枢纽元，一般是取左端、右断和中间三个数，也可以随机选取。（REF[1]）

1
2
3
4
5
6
7
8
9

int select_pivot_median3(T A[], int p, int q)
{
    int m = (p + q)/2;
    /* swap to ensure A[m] <= A[p] <= A[q] */
    if (A[p] < A[m]) swap(A[p], A[m]);
    if (A[q] < A[m]) swap(A[q], A[m]);
    if (A[q] < A[p]) swap(A[q], A[p]);
    return A[p];
}

b.按枢纽元将数组分成左右两部分

虽然说分割方法只影响算法时间复杂度的系数，但是一个好系数也是比较重要的。这也就是为什么实际应用中宁愿选择可能退化成O(n^2)的快速排序，也不用稳定的堆排序（堆排序交换次数太多，导致系数很大）。

常见的分割方法有三种：

单向扫描

单向扫描代码非常简单，只有短短的几行，思路也比较清晰。该算法由N.Lomuto提出，算法导论上也采用了这种算法。对于数组A[p...q]，该算法用一个循环扫描整个区间，并维护一个标志m，使得循环不变量（loop invariant）A[p＋1...m] < A[p] && A[m+1, i-1] >= x[l]始终成立。（REF[2],REF[3]）

1
2
3
4
5
6
7
8
9
10
11
12

int partition(T A[], int p, int q)
{
    int x = select_pivot(A, p, q);
    int m = p, j;
    for (int j = p+1; j <= q; ++j)
        /* invariant : A[p＋1...m] < A[p] && A[m+1, i-1] >= x[q] */
        if (A[j] <= x)
            swap(A[++m], A[j]) 
    swap(A[p], A[m]); 
    /* A[p...m-1] < A[m] <= A[m+1...u] */
    return m;
}

顺便废话几句，在看国外的书的时候，发现老外在分析和测试算法尤其是循环时，非常重视不变量（invariant）的使用。确立一个不变量，在循环开始之前和结束之后检查这个不变量，是一个很好的保持算法正确性的手段。

事实上第一种算法需要的交换次数比较多，而且如果采用选取左端元素作为枢纽元的方法，该算法在输入数组中元素全部相同时退化成O(n^2)。第二种方法可以避免这个问题。

双向扫描

双向扫描用两个标志i、j，分别初始化成数组的两端。主循环里嵌套两个内循环：第一个内循环i从左向右移过小于枢纽元的元素，遇到大元素时停止；第二个循环j从右向左移过大于枢纽元的元素，遇到小元素时停止。然后主循环检查i、j是否相交并交换A[i]、A[j]。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int partition(T A[], int p, int q)
{
    int x = select_pivot(A, p, q);
    int i = p, j = q + 1;
    for ( ; ; )
    {
        do ++i; while (i <= q && A[i] < x);
        do --j; while (A[j] > x);
        if (i > j) break;
        swap(A[i], A[j]);
    }
    swap(A[p], A[j]);
    return j;
}

双向扫描可以正常处理所有元素相同的情况，而且交换次数比单向扫描要少。

Hoare的双向扫描

这种方法是Hoare在62年最初提出快速排序采用的方法，与前面的双向扫描基本相同，但是更难理解，手算了几组数据才搞明白：（REF[2]）

1
2
3
4
5
6
7
8
9
10
11
12

int partition(T A[], int p, int q)
{
    int x = select_pivot(A, p, q);
    int i = p - 1, j = q + 1;
    for ( ; ; )
    {
        do --j; while (A[j] > x);
        do ++i; while (A[i] < x);
        if (i < j) swap(A[i], A[j])
        else return j;
    }
}

需要注意的是，返回值j并不是枢纽元的位置，但是仍然保证了A[p..j] <= A[j+1...q]。这种方法在效率上于双向扫描差别甚微，只是代码相对更为紧凑，并且用A[p]做哨兵元素减少了内层循环的一个if测试。

http://www.see2say.com/channel/music/player.aspx?v_album_id=9804

改进的双向扫描

枢纽元保存在一个临时变量中，这样左端的位置可视为空闲。j从右向左扫描，直到A[j]小于等于枢纽元,检查i、j是否相交并将A[j]赋给空闲位置A[i],这时A[j]变成空闲位置；i从左向右扫描，直到A[i]大于等于枢纽元,检查i、j是否相交并将A[i]赋给空闲位置A[j]，然后A[i]变成空闲位置。重复上述过程，最后直到i、j相交跳出循环。最后把枢纽元放到空闲位置上。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int partition(T A[], int p, int q)
{
    int x = select_pivot(A, p, q);
    int i = p, j = q;
    for ( ; ; )
    {
        while (i < j && A[j] > x) --j;
        A[i] = A[j];
        while (i < j && A[i] < x) ++i;
        A[j] = A[i];
    }
    A[i] = x;  // i == j
    return i;
}

这种类似迭代的方法，每次只需一次赋值，减少了内存读写次数，而前面几种的方法一次交换需要三次赋值操作。由于没有哨兵元素，不得不在内层循环里判断i、j是否相交，实际上反而增加了很多内存读取操作。但是由于循环计数器往往被放在寄存器了，而如果待排数组很大，访问其元素会频繁的cache miss，所以用计数器的访问次数换取待排数组的访存是值得的。

关于双向扫描的几个问题

1.内层循环中的while测试是用“严格大于/小于”还是”大于等于/小于等于”。

一般的想法是用大于等于/小于等于，忽略与枢纽元相同的元素，这样可以减少不必要的交换，因为这些元素无论放在哪一边都是一样的。但是如果遇到所有元素都一样的情况，这种方法每次都会产生最坏的划分，也就是一边1个元素，令一边n－1个元素，使得时间复杂度变成O(N^2)。而如果用严格大于/小于，虽然两边指针每此只挪动1位，但是它们会在正中间相遇，产生一个最好的划分，时间复杂度为log(2,n)。

另一个因素是，如果将枢纽元放在数组两端，用严格大于/小于就可以将枢纽元作为一个哨兵元素，从而减少内层循环的一个测试。
由以上两点，内层循环中的while测试一般用“严格大于/小于”。

2.对于小数组特殊处理

按照上面的方法，递归会持续到分区只有一个元素。而事实上，当分割到一定大小后，继续分割的效率比插入排序要差。由统计方法得到的数值是50左右(REF[3])，也有采用20的（REF[1]）, 这样原先的QuickSort就可以写成这样

1
2
3
4
5
6
7
8
9
10
11

void QuickSort(T A[], int p, int q)
{
    if (q - p > cutoff) //cutoff is constant 
    {
        int q = Partition(A, p, q);
        QuickSort(A, p, q-1);
        QuickSort(A, q+1, r);
    }
    else
        InsertionSort(T A[], p, q); //user insertion sort for small arrays
}

二、分治

分治这里看起来没什么可说的，就是一枢纽元为中心，左右递归，实际上也有一些技巧。

1.尾递归（Tail recursion）

快排算法和大多数分治排序算法一样，都有两次递归调用。但是快排与归并排序不同，归并的递归则在函数一开始， 快排的递归在函数尾部，这就使得快排代码可以实施尾递归优化。第一次递归以后，变量p就没有用处了， 也就是说第二次递归可以用迭代控制结构代替。虽然这种优化一般是有编译器实施，但是也可以人为的模拟：

1
2
3
4
5
6
7
8
9

void QuickSort(T A[], int p, int q)
{
    while (p < q)
    {
        int m = Partition(A, p, q);
        QuickSort(A, p, m-1);
        p = m + 1;
    }
}

采用这种方法可以缩减堆栈深度，由原来的O(n)缩减为O(logn)。

三、参考文献：

Related Post

• [备忘]倒置字符串中的单词 (0)
• [一道面试题]含有*的字符串匹配问题 (5)
• Fibonacci数的巧妙求法 (2)

看到倒置，一般的做法是用栈，要么自己建个数组、要么STL，或者递归用程序栈。

优雅的递归

void reverse_token() {
  char str[MAX] = {0};
  if (scanf("%[^#]", str) != EOF)  { //利用scanf的正则式特性
      getchar();
      reverse_token();
      printf("%s ", str);
  } 
}

STL list

void reverse_token() {
    char tmp[MAX];
    list<string> stack;
    while (cin.getline(tmp, MAX, '#')) stack.push_front(string(tmp));
    copy(stack.begin(), stack.end(), ostream_iterator<string>(cout," "));
}

如果是处理字符串, 而不是stdin, 可以改用sscanf()或者STL的范型算法find, 更标准的做法是strtok()。想到了javascript里的String().split(‘x’)，直接返回一个分割后的数组，相当的方便。

Related Post

• 快速排序详细分析 (4)
• [一道面试题]含有*的字符串匹配问题 (5)
• Fibonacci数的巧妙求法 (2)

做一个小程序的时候发现的。代码如下，使用的编译器为DEV-C++ 4.9.9.2。
如果先要求输入a,再要求输入b,那么a的值无论输入多少(少于255)输出都会是0；
反过来，如果先要求输入b，再要求输入a，那么就会正常。
这是为什么呢？请教达人解释。

#include
#include
 
int main(int argc,char **argv)
{
    unsigned char a,b;
    scanf("%d",&a);
    scanf("%d",&b);
    printf("a=%d,b=%d\n",a,b);
    scanf("%d",&b);
    scanf("%d",&a);
    printf("a=%d,b=%d\n",a,b);
    system("pause");
}

devcpp用的是gcc编译器，自己用gcc试了一下，果然是这样。为什么出现这种问题呢？开gdb调试，信息如下：

main (argc=1, argv=0xbfbaf3e4) at a.c:7
7           scanf("%d",&a);
(gdb) n
1
8           scanf("%d",&b);
(gdb) p a
$1 = 1 '\001'
(gdb) n
2
9           printf("a=%d,b=%d\n",a,b);
(gdb) p a
$2 = 0 '\0'
(gdb) p b
$3 = 2 '\002'
(gdb)

从第12行可以看出，在第一次scanf读入b后，a的值被清0了，这样原因就好分析了。用%d读b的时候，实际上把b转型成了int，即scanf(“%d”,&b)实际上等于 int * p = &b; *p = 2 ，因为scanf接受的参数是指针。问题明显了，int4个字节，char1个字节，scanf实际上向内存里写了4个字节，高地址的3个字节为0，把a的1个字节和前面的参数区的2个字节给覆盖了。

如果声明顺序反过来，b在高地址，就不会把a覆盖，覆盖掉的是栈头部的参数区的3个字节。

但是无论那种方法，都是危险的，都会造成数据丢失。gcc 在开启 -Wall 开关后会给出警告

 warning: format ‘%d’ expects type ‘int *’, but argument 2 has type ‘char *’

（这个warning应该是针对c标准库函数设计的）。

这种转型实际上C++其实是不允许的。比如

char a; int * p = &a;

编译器(g++)会毫不客气的给出一个error：

error: cannot convert ‘char*’ to ‘int*’ in initialization

但是实际上那段“问题代码”仍然可以编译通过。为什么呢？查看了stdio.h，scanf函数的原型如下：

extern int scanf (__const char *__restrict __format, ...)

printf最后一个参数”…”是一个变长参数，传参时实际传了一个void*进去，真正的类型分析和转型动在printf函数定义内的va_arg宏完成。所以编译器在分析这个函数调用时是无法知到真正的参数类型的。而scanf定义部分早被编译成了2进制lib。所以这段代码在c++中也可以编译通过。

另外有人说Intel C编译器没有这个问题，自己试了一下vc也没这个问题，这令我很费解。个人觉得这个问题似乎很难避免，因为这种用变长参数列表传递的参数，参数类型完全由前面的format string决定，可惜搞不到源码，就没法深究了。

Related Post

• No Related Post