C on ZRJ | 学习笔记

比较字符串形式的版本号

Tue, 15 Sep 2015 20:54:34 +0800

版本号是一个字符串，主要考虑以下三种用例，点分的个数一致还好，不一致需要注意

#include <boost/algorithm/string.hpp>
#include <algorithm>
#include <vector>
#include <string>

bool version_less_than(std::string str_version_a, std::string str_version_b)
{
    std::vector<std::string> vec_version_a, vec_version_b;
    boost::split(vec_version_a, str_version_a, boost::is_any_of("."));
    boost::split(vec_version_b, str_version_b, boost::is_any_of("."));
    return std::lexicographical_compare(vec_version_a.begin(), vec_version_a.end(), vec_version_b.begin(), vec_version_b.end());
}

int main() {
    {
        std::string str_version_a = "4.1.1", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    {
        std::string str_version_a = "4.1", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    {
        std::string str_version_a = "4.1.1", str_version_b = "4.1";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    return 0;
}

运行结果

1
1
0

另外，对于比较，只需要通过一个小于比较运算，就可以满足小于，大于的比较，等于的比较可以通过两次小于比较来达成

-————————————

2015-9-16 09:33:20 发现上面的方法是有问题的，看这个用例

#include <boost/algorithm/string.hpp>
#include <algorithm>
#include <vector>
#include <string>

bool version_less_than(std::string str_version_a, std::string str_version_b)
{
    std::vector<std::string> vec_version_a, vec_version_b;
    boost::split(vec_version_a, str_version_a, boost::is_any_of("."));
    boost::split(vec_version_b, str_version_b, boost::is_any_of("."));
    return std::lexicographical_compare(vec_version_a.begin(), vec_version_a.end(), vec_version_b.begin(), vec_version_b.end());
}

int main() {
    {
        std::string str_version_a = "4.1.10", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    return 0;
}

输出

问题的本质还是拿字符串当做数字来比较了，这么改

#include <boost/algorithm/string.hpp>
#include <boost/lexical_cast.hpp>
#include <algorithm>
#include <vector>
#include <string>

bool version_less_than(std::string str_version_a, std::string str_version_b) {
    std::vector<std::string> vec_str_version_a, vec_str_version_b;
    boost::split(vec_str_version_a, str_version_a, boost::is_any_of("."));
    boost::split(vec_str_version_b, str_version_b, boost::is_any_of("."));
    std::vector<int> vec_int_version_a, vec_int_version_b;
    std::transform(vec_str_version_a.begin(), vec_str_version_a.end(), std::back_inserter(vec_int_version_a), boost::lexical_cast<int, std::string>);
    std::transform(vec_str_version_b.begin(), vec_str_version_b.end(), std::back_inserter(vec_int_version_b), boost::lexical_cast<int, std::string>);
    return std::lexicographical_compare(vec_int_version_a.begin(), vec_int_version_a.end(), vec_int_version_b.begin(), vec_int_version_b.end());
}

int main() {
    {
        std::string str_version_a = "4.1.1", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    {
        std::string str_version_a = "4.1", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    {
        std::string str_version_a = "4.1.1", str_version_b = "4.1";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }
    {
        std::string str_version_a = "4.1.10", str_version_b = "4.1.2";
        printf("%d\n", version_less_than(str_version_a, str_version_b));
    }    
    return 0;
}

固然可以实现，但是感觉就笨重了好多，查了一下，leetcode 上面是有这个题的，https://leetcode.com/problems/compare-version-numbers/，按照 acm 流的写法，肯定就是自己手解字符串了，就像这样，http://ask.julyedu.com/question/114

再谈对非阻塞的理解

Mon, 20 Jul 2015 19:21:37 +0800

一般来说，现在大家 epoll 都是搭配着非阻塞 IO 一起用的，要问为什么？大家都这么用的啊，而且异步嘛，非阻塞嘛，很自然嘛

但是，非阻塞 IO 具体是怎么对 send 和 recv 起作用的。一般理解，我们之所以要用非阻塞，是为了避免这种情况：

客户端跟我们 tcp 三次握手完了，我们 listen fd 上得到一个 IN 事件了，然后 accept，得到一个新的 client fd，然后如果这个时候，客户端没有发字节流过来，我们调用 recv，就会因为服务器的系统缓冲区中空空如也，陷入阻塞，所以如果这里我们用上非阻塞，就可以让 recv 快速的返回一个 0，从而让 CPU 转而去处理其他 client fd，所以，非阻塞对 recv 的作用效果是很明显的。

但是 send 呢，即使是在阻塞情况下，我们调用 send，系统都是把我们的数据拷贝到系统缓冲区，然后就返回了，而并不需要等到这些数据真正发出来收到 ack 之后才返回，也就是说，这里纯粹是一个内存拷贝的动作，不涉及和远端机器的交互，照理说，应该是不会陷入等待的。那是否就能说阻塞非阻塞对于 send 来说不那么重要呢？也不尽然，考虑到出现系统发送缓冲区满了的情况，这时我们需要等待缓冲区发送一部分之后，腾出地方来，我们 send 的数据才能拷贝进去，在这种情况下，貌似就要依靠非阻塞才行了，非阻塞下 send 会快速的返回一个失败，好让我们采取其他的措施。

那么，接下来看这个代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <time.h>
#include <sys/epoll.h>
#include <map>
#include <string>

#define  _PRINTF_(format, ...) printf("[%s] " format " [%s::%s::%d]\n", getdatetimestr(), ##__VA_ARGS__, __FILE__, __FUNCTION__, __LINE__)

char* getdatetimestr() {
    static char datetimestr[32] = {0};
    static time_t last_update_time = 0;
    struct timeval tv = {0};
    gettimeofday(&tv, NULL);
    time_t nowtime = tv.tv_sec;
    if (nowtime != last_update_time) {
        last_update_time = nowtime;
        struct tm nowtm = {0};
        localtime_r(&nowtime, &nowtm);
        strftime(datetimestr, sizeof(datetimestr), "%Y-%m-%d %H:%M:%S", &nowtm);
    }
    snprintf(datetimestr+19, sizeof(datetimestr)-19, ".%06ld", tv.tv_usec);
    return datetimestr;
}

int ctl_epoll_event(int epoll_fd, int ctl, int fd, int event) {
    // EPOLL IN = 0x001,
    // EPOLL PRI = 0x002,
    // EPOLL OUT = 0x004,
    // EPOLL RDNORM = 0x040,
    // EPOLL RDBAND = 0x080,
    // EPOLL WRNORM = 0x100,
    // EPOLL WRBAND = 0x200,
    // EPOLL MSG = 0x400,
    // EPOLL ERR = 0x008,
    // EPOLL HUP = 0x010,
    // EPOLL ET = (1 << 31)

    // EPOLL_CTL_ADD 1
    // EPOLL_CTL_DEL 2
    // EPOLL_CTL_MOD 3
    
    //_PRINTF_("epoll_fd %d, ctl %d, fd %d, event %d", epoll_fd, ctl, fd, event);
    struct epoll_event ev;
    ev.data.fd = fd;
    ev.events = event;
    return epoll_ctl(epoll_fd, ctl, fd, &ev);
}

int httpSrv2(short port) {
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd == -1) {
        _PRINTF_("%m");
        return -1;
    }
    int reuseaddr = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr));
    struct sockaddr_in server_addr = {0};
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(port);
    if (bind(listen_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        _PRINTF_("%m");
        return -1;
    }
    if (listen(listen_fd, 32) == -1) {
        _PRINTF_("%m");
        return -1;
    }
    _PRINTF_("listening...");
    int epoll_fd = epoll_create(4096);
    if (ctl_epoll_event(epoll_fd, EPOLL_CTL_ADD, listen_fd, EPOLLIN) == -1) {
        _PRINTF_("%m");
        return -1;
    }
    std::map<int, std::string> fd_buffer_map;
    for (int count = 0; ; ) {        
        struct epoll_event epoll_events[64] = {{0}};
        int epoll_events_num = epoll_wait(epoll_fd, epoll_events, sizeof(epoll_events)/sizeof(epoll_events[0]), 5*1000);
        //_PRINTF_("epoll_events_num, %d", epoll_events_num);
        for (int epoll_events_index =  0; epoll_events_index < epoll_events_num; epoll_events_index++) {
            int event_fd = epoll_events[epoll_events_index].data.fd;
            if (event_fd == listen_fd) {
                if (!(epoll_events[epoll_events_index].events & EPOLLIN)) {
                    _PRINTF_("listen fd event: %d, msg: %m", epoll_events[epoll_events_index].events);
                    continue;
                }                
                int client_fd = accept(listen_fd, (struct sockaddr*)NULL, NULL);
                //int client_fd = accept4(listen_fd, (struct sockaddr*)NULL, NULL, SOCK_NONBLOCK);
                if (client_fd == -1) {
                    _PRINTF_("%m");
                    continue;
                }
                ctl_epoll_event(epoll_fd, EPOLL_CTL_ADD, client_fd, EPOLLIN);
            } else {
                int client_fd = event_fd;
                if (epoll_events[epoll_events_index].events & EPOLLIN) {
                    char recv_buff[64*1024] = {0};
                    int recv_len = recv(client_fd, recv_buff, sizeof(recv_buff), 0);
                    if (recv_len < 0) {
                        _PRINTF_("%m");
                        continue;
                    }
                    fd_buffer_map[client_fd].append(recv_buff, recv_len);
                    //_PRINTF_("fd %d buffer [%s]", client_fd, fd_buffer_map[client_fd].c_str());
                    if (fd_buffer_map[client_fd].find("\r\n\r\n") == std::string::npos) {
                        continue;
                    }
                    char response[] = "HTTP/1.1 200 OK\r\n\r\n<h1>Hello World</h1>";
                    if (send(client_fd, response, sizeof(response)-1, 0) < 0) {
                        _PRINTF_("%m");
                    }
                    if (count++ % 100000 == 0) {
                        _PRINTF_("count %d, last request [%s], last response [%s]", count, fd_buffer_map[client_fd].c_str(), response);
                    }
                    ctl_epoll_event(epoll_fd, EPOLL_CTL_DEL, client_fd, EPOLLIN);
                    close(client_fd);
                    fd_buffer_map.erase(client_fd);
                } else {
                    _PRINTF_("client fd event: %d, msg: %m", epoll_events[epoll_events_index].events);
                }
            }
        }
    }
    close(epoll_fd);
    close(listen_fd);
    return 0;
}

int main(int argc, char** argv) {
    _PRINTF_("starting server...");
    httpSrv2(atoi(argv[1]));
    return 0;
}

这个代码通过 95/96 行可以切换阻塞和非阻塞模式，在两种模式中，其实服务的吞吐量差不多，但是，阻塞的代码，CPU 跑到了 100%（一个核上 100%，其他核空闲），非阻塞的代码，同样的吞吐率，CPU 只用了不到 10%，这是为什么呢？

-———————–

2015-7-20 19:37:42 进一步的观察发现，非阻塞的 10% CPU 使用率，只是在进程刚启动的时候，在进程运行一段时间之后，也会跑到 100% 的 CPU

getdatetimestr

Fri, 17 Jul 2015 18:54:24 +0800

下午写了这么一个函数

char* getdatetimestr() {
    static char datetimestr[32] = {0};
    static time_t last_update_time = 0;
    struct timeval tv = {0};
    gettimeofday(&tv, NULL);
    time_t nowtime = tv.tv_sec;
    if (nowtime != last_update_time) {
        last_update_time = nowtime;
        struct tm nowtm = {0};
        localtime_r(&nowtime, &nowtm);
        strftime(datetimestr, sizeof(datetimestr), "%Y-%m-%d %H:%M:%S", &nowtm);
    }
    snprintf(datetimestr+19, sizeof(datetimestr)-19, ".%06ld", tv.tv_usec);
    return datetimestr;
}

返回的串类似 2015-07-17 18:51:06.709628

注意到其中有一个缓存的机制，对于同一秒的时间单位内，只格式化微秒的部分，复用秒和秒以左的字符串，这个优化的差别有多大呢，实测下来，在同一个机器上，不用这个优化，每秒大约 5 万次，用了这个优化，每秒大约 50 万次。

对有符号数的位移操作

Thu, 17 Apr 2014 19:40:34 +0800

来看代码

#include <stdio.h>

int main() {
    int a = 0x80000000;
    int b = a>>1;
    int c = a>>2;
    int d = a>>31;
    int e = a>>32;
    printf("%d\n%d\n%d\n%d\n%d\n", a, b, c, d, e);
    return 0;
}

这个东西的输出是什么呢

vs2005 和 gcc 4.1.2 都是

-2147483648
-1073741824
-536870912
-1
-2147483648

为什么呢

首先，a 的值，是一个 32 位，最高位为 1，其余都为 0，那么打印出 -2147483648 不奇怪，但是，接下来的，b，我们把 a 右移一位，照理说，这个时候，应该是最高位为 0，然后次高位为 1，打印的应该是 1073741824，而实际上打出来的却是 -1073741824，那么说明，他的最高位和次高位都为 1 了，也就是说，符号位在位移的时候被保留了，嗯，这个也好吧，然后 c，这个的最高位，次高位，次次高位，都是 1，也就是说，就像移动的时候会复制一样，那么 d 就可以理解为什么会是 -1 了，因为比特位全部都是 1 了，但是，e 呢，这个其实在编译的时候有报警告，说行为未定义，但是按照之前的搞法，这个应该也是 -1 啊，不过六道轮回，这个又变成只有最高位为 1 了，真是一个神奇的世界。

http://www.cnblogs.com/weiweishuo/archive/2013/05/25/3099090.html，http://blog.chinaunix.net/uid-26941022-id-3223869.html，这里有一些讨论

写一个日志模块

Thu, 05 Sep 2013 20:48:27 +0800

今天在写一个日志模块，遇到一些问题，学到了一些东西，记一下。

一开始想到，cpp 这么成熟的社区，日志这么基本的模块，应该现成的有很多吧，随便找一个来用就可以了，上网搜了一圈，发现真是一团混乱啊，看到这里，http://blog.csdn.net/junchaox/article/details/7346514

待选为 glog、log4cplus、log4cpp、log4cxx

目前准备使用glog，使用方便，性能也不错，待进一步试验，如果有不能满足的功能就转用 log4cplus，功能很全面，不过稍复杂些。

其它两个都是三年前就没更新，没好感，暂不准备使用。

1.log4cplus 最新版本：1.1.0 2012-03-11

下载地址：http://sourceforge.net/projects/log4cplus/files/log4cplus-stable/1.1.0

功能全面，使用稍复杂。

代码示例：

#include <log4cplus/layout.h>  
  
#include <log4cplus/configurator.h>  
  
#include <iomanip>  
  
SharedAppenderPtr pFileAppender(new FileAppender("testlog.log"));  
  
Logger pTestLogger = Logger::getInstance("LoggerName");  
  
pTestLogger.addAppender(pFileAppender);   
  
sprintf(a,"%d",i);  
  
LOG4CPLUS_WARN(pTestLogger, "This is a <Warn> log message..." << a );

2.log4cxx 最新版本： 0.10.0 2008-04-03

下载地址：http://logging.apache.org/log4cxx/download.html 编译很麻烦新的版本0.10.0需要使用Apache的产品Ant来编译，而Ant又需要JDK。。。

怕麻烦，没有下载测试。

3. glog 最新版本： 0.3.2 2012-1-12

下载地址：http://code.google.com/p/google-glog/downloads/list

使用方便，性能也不错。

Google Glog 是一个C++语言的应用级日志记录框架，提供了 C++ 风格的流操作和各种助手宏。

Google glog是一个基于程序级记录日志信息的c++库，编程使用方式与c++的stream操作类似

代码示例：

#include <glog/logging.h>  
  
google::InitGoogleLogging(argv[0]);  
  
google::SetLogDestination(google::INFO,"./myInfo_");  
  
LOG(INFO) << "This is a <Warn> log message..." << i;

Log4cpp 最新版1.0.x 2007-09-03

下载地址： http://sourceforge.net/projects/log4cpp/files

感觉跟 log4cplus类似，结构稍简单些，不过代码也不少写。

#include <log4cpp/Category.hh>  
#include <log4cpp/PropertyConfigurator.hh>  
#include <log4cpp/NDC.hh>  
#include <log4cpp/FileAppender.hh>  
#include <log4cpp/BasicLayout.hh>  
log4cpp::Layout* layout = new log4cpp::BasicLayout();  
log4cpp::Appender* appender = new log4cpp::FileAppender("FileAppender", "./test_log4cpp1.log");  
appender->setLayout(layout);  
log4cpp::Category& warn_log = log4cpp::Category::getInstance("mywarn");  
warn_log.setAdditivity(false);  
warn_log.setAppender(appender);  
warn_log.setPriority(log4cpp::Priority::WARN);  
warn_log.critStream() << "This is a <Warn> log message..." << i;

看到上面的那些东西，真是令人望而生畏，我这才理解为什么之前看到的几个开源项目都是自己实现了一个日志类，好吧，cpp 程序员就是喜欢重复造轮子，术语叫什么来着，not invented here

好吧，既然求开源而不得，那只能自己动手丰衣足食了，总的来说，我们希望这个日志模块满足以下几个特点：

易用，最好是只要 include 一个头文件，然后就可以用了，退一步，我们可以接受在使用之前调用一次 init 函数，不需要另外编译依赖库，更不要安装。
轻量，对业务的能耗尽量减少到最小。
实现简洁。用尽量少的代码实现。
线程安全。
输出层级可控。
异步落地磁盘，而且按照文件大小或者时间自动滚动。

而最终的效果，使用上，我们希望是这样的用法。

init_log();
LOG_DEBUG("test log %d", 123);
LOG_ERR("test err %s", "456");

这个地方，之所以用 c 的转义，而不用 cpp 的流式，一个是考虑到效率，一个是考虑到现有的代码兼容。

首先上来遇到的第一个问题，我们需要打印行号，文件名，函数名等等，这些怎么得到呢，想到用宏，__LINE__，__FILE__，等等，但是，宏展开之后，需要调用我们自己的函数吧，这些可变参数怎么从我们的函数传到 printf 呢？

在这个地方纠结了很久，一开始去找各种 va_list 的传递方法，发现这个几乎是不可能的，于是后面又找了 vsnprintf 这种的函数，才发现有这么一类可以直接接收 va_list 的函数存在。

然后就是日志类的初始化问题，一开始，想到用类的静态函数来做，但是又发现，这样的话，也是有问题的，于是后面用单例来做。

然后就是异步的问题，这个是想到先把日志存到内存，然后用线程异步写入磁盘文件。但是遇到问题是，内存要怎么布局呢，如果我们把内存连续的用起来，那么，多个线程同时写的时候，怎么解决字符串交错的问题呢，如果用锁，那么性能必然大大下降。

另外的一个问题是，我们申请一片定长内存，然后把它当作循环队列来用，但是，在快到结尾的时候，例如，假如还剩下 50 个字符的空间，但是有一条日志过来了，而这个日志要占用 100 个字符，那怎么处理剩下的 50 个呢，按照循环队列的意义，应该转到头部继续写的，但是，到时候怎么打印出来呢。如果不截断的话，有什么办法解决呢。而且更麻烦的问题是，在一个字符串被格式化完成之前，我们是不知道这个字符串会有多长的。

对于这个问题，有一个办法是，我们留下一部分内存空间，当作保留区，例如，我们申请 15M，但是只有 14M 是拿来当循环队列的，那么，当指针超过 14 的时候，下一条就回来开始的地方了，这样的话，就要限定，刚好在 14 M 边缘的那条，单行不能超过 1MB，这个限制，应该还是可以接受的。

但是依然没有解决多线程的并发写入问题。

这个问题，或许用一个二维的字符型数组来实现，然后用下标的原子操作来避免多线程混叠，但是，这样的话，我们就需要按照最长的可能单行来分配，那么，就必然造成大量的空间浪费，特别是在最长的单行比大多数的单行都长很多倍的情况下。

待续。

历史评论

wanax (2013-09-23 15:36:44):

iphone开发下面有个开源日志还可以打印图片的….客户端输出还不是控制台碉堡了

ZRJ (2013-09-23 18:49:18):

堂堂 c++ 一大帮人在用，居然连个日志标准都没有。。

cc 和 cpp 混合情况的 makefile

Thu, 29 Aug 2013 20:31:44 +0800

今天需要写一个 makefile，项目里面有 pb 生成的 cc 和 cpp 文件，分别要生成各自的 obj，以前没有遇到过这种 cc 和 cpp 混合的情况，上网找了一下，找到这个模版，http://lcinx.blog.163.com/blog/static/434942672010913291210/：

#
# c.cpp混合编译的makefile模板
#
#


BIN = test.exe
CC = gcc
CPP = g++
#这里只加入库头文件路径及库路径
INCS = -I"c:/mingw/include"
LIBS = -L"c:/mingw/lib"
SUBDIRS =
#生成依赖信息时的搜索目录，比如到下列目录中搜索一个依赖文件(比如.h文件)，例如 -I"./***/" -I"./base/"
DEFINC =
#给INCS加上依赖搜索路径，分开写可能会产生不一致情况，而且繁琐
INCS += $(DEFINC)
#
#
#maintest.c tree/rbtree.c  多了子目录，那就直接添加 目录/*.c即可   所有的源文件--  .c文件列表
CSRCS = $(wildcard ./*.c)
CPPSRCS = $(wildcard ./*.cpp)
#SRCS += $(wildcard ./../base/*.c)
#SRCS += $(wildcard ./*.c ./src/*.c ./src/base/*.c ./src/base/tree/*.c ./src/mem/*.c)

#
#
#所有的.o文件列表
COBJS := $(CSRCS:.c=.o)
CPPOBJS := $(CPPSRCS:.cpp=.o)
#
#生成依赖信息 -MM是只生成自己的头文件信息，-M 包含了标准库头文件信息。
#-MT 或 -MQ都可以改变生成的依赖  xxx.o:src/xxx.h 为 src/xxx.o:src/xxx.h 当然。前面的 src/xxx.o需自己指定
#格式为 -MM 输入.c或.cpp  查找依赖路径  -MT或-MQ  生成规则，比如src/xxx.o 
MAKEDEPEND = gcc -MM -MT
CFLAGS += $(INCS)
CFLAGS += -O2 -Wall -fomit-frame-pointer -g -ansi
CPPFLAGS += $(INCS)
CPPFLAGS += -O2 -Wall -g
#-g 生成调试信息
#-pedantic参数与-ansi一起使用 会自动拒绝编译非ANSI程序
#-fomit-frame-pointer 去除函数框架
#-Wmissing-prototypes -Wstrict-prototypes 检查函数原型
#针对每个.c文件的.d依赖文件列表
CDEF = $(CSRCS:.c=.d)
CPPDEF = $(CPPSRCS:.cpp=.d)

all:$(BIN)

#生成.o的对自己目录中.h .c的依赖信息.d文件到.c所在的路径中
#$(DEF)文件是.d文件名列表(含目录)，比如tree.d 匹配成功那么%就是tree，然后在尝试%.c，如果成功。则执行规则
# $(<:.c=.o)是获取此.c文件的名字(含路径)，然后变为.o比如 src/xxx.o。 以形成如下
# src/xxx.o : src/xxx.c ***.h  ***.h  最前面！！注意。  
# 此做法是每个.d都和生成他的.c在一个目录里，所以需要这样做。
# $(<:.c=.o)之类的 。此时的<相当于变量$< 。切记
# : : :  含义同下
$(CDEF) : %.d : %.c
    $(MAKEDEPEND) $(<:.c=.o) $< $(DEFINC) > $@
$(CPPDEF) : %.d : %.cpp
    $(MAKEDEPEND) $(<:.cpp=.o) $< $(DEFINC) > $@

#先删除依赖信息
#重新生成依赖信息
#这里出现了一个 $(MAKE) 没有定义的变量。这个变量是由 Make 自己定义的，它的值即为自己的位置，方便 Make 递归调用自己。
depend:
    rm $(CDEF)
    rm $(CPPDEF)
    $(MAKE) $(CDEF)
    $(MAKE) $(CPPDEF)

#$(OBJS):%.o :%.c  先用$(OBJS)中的一项，比如foo.o: %.o : %.c  含义为:试着用%.o匹配foo.o。如果成功%就等于foo。如果不成功，
# Make就会警告，然后。给foo.o添加依赖文件foo.c(用foo替换了%.c里的%)
# 也可以不要下面的这个生成规则，因为下面的 include $(DEF)  就隐含了。此处为了明了，易懂。故留着
$(COBJS) : %.o: %.c
    $(CC) -c $< -o $@ $(CFLAGS)
$(CPPOBJS) : %.o: %.cpp
    $(CPP) -c $< -o $@ $(CPPFLAGS)

# $@--目标文件，$^--所有的依赖文件，$<--第一个依赖文件。每次$< $@ 代表的值就是列表中的
#
$(BIN) : $(COBJS) $(CPPOBJS)
    $(CC) -o $(BIN) $(COBJS) $(CPPOBJS) $(LIBS)
    rm $(COBJS)
    rm $(CPPOBJS)
    rm $(CDEF)
    rm $(CPPDEF)
# 链接为最终目标


#引入了.o文件对.c和.h的依赖情况。以后.h被修改也会重新生成，可看看.d文件内容即知道为何
#引入了依赖就相当于引入了一系列的规则，因为依赖内容例如： 目录/xxx.o:目录/xxx.c 目录/xxx.h 也相当于隐含的引入了生成规则
#故上面不能在出现如： $(OBJS) : $(DEF)之类。切记
include $(CDEF)
include $(CPPDEF)
.PHONY:clean cleanall

#清除所有目标文件以及生成的最终目标文件
clean:            
    rm $(BIN) $(COBJS) $(CPPOBJS)
#rm *.d
cleanall:
    rm $(CDEF) $(CPPDEF)
    rm $(BIN) $(COBJS) $(CPPOBJS)

但是其实我写的东西不用这么复杂，本着能少写一个字母就少写一个字母的原则，我最终的 makefile 如下：

BIN = GenPbPerfTest

CXX = g++
CXX_FLAGS = -g -Wall -DDEBUG
LIBS = -lprotobuf
INCS =

CC_SRCS = $(wildcard *.cc)
CPP_SRCS = $(wildcard *.cpp)

CC_OBJS = $(patsubst %.cc,%.o, $(CC_SRCS))
CPP_OBJS = $(patsubst %.cpp,%.o, $(CPP_SRCS))
OBJS = $(CC_OBJS) $(CPP_OBJS)

all : $(BIN)

$(BIN) : $(OBJS)
	$(CXX) $(CXX_FLAGS) $(LIBS) -o $@ $^
    
$(CC_OBJS) : %.o : %.cc
	$(CXX) $(CXX_FLAGS) $(INCS) -c $<
    
$(CPP_OBJS) : %.o : %.cpp
	$(CXX) $(CXX_FLAGS) $(INCS) -c $<
    
.PHONY : clean
clean:
	rm -f *.o $(BIN)

功能没有那么强大，最大的缺失是对于 h 文件的依赖关系没有考虑进来，不过也够用了，实在不行就 make clean && make 一下嘛，哈哈

=================================================

2013-08-29 20:34:48

BIN = GenPbPerfTest

CXX = g++
CXX_FLAGS = -g -Wall -DDEBUG
LIBS = -lprotobuf
INCS =

CC_SRCS = $(wildcard *.cc)
CPP_SRCS = $(wildcard *.cpp)

CC_OBJS := $(CC_SRCS:.cc=.o)
CPP_OBJS := $(CPP_SRCS:.cpp=.o)
OBJS = $(CC_OBJS) $(CPP_OBJS)

all : $(BIN)

$(BIN) : $(OBJS)
	$(CXX) $(CXX_FLAGS) $(LIBS) -o $@ $^
    
$(CC_OBJS) : %.o : %.cc
	$(CXX) $(CXX_FLAGS) $(INCS) -c $<
    
$(CPP_OBJS) : %.o : %.cpp
	$(CXX) $(CXX_FLAGS) $(INCS) -c $<
    
.PHONY : clean
clean:
	rm -f *.o $(BIN)

后来发现可以少写几个字母，改动在 11 12 行

=========================================================================

2013-08-29 20:37:25 买一送一，http://www.sf.org.cn/Article/base/200701/19975.html，这里有个通用的

###############################################################################
#
# Generic Makefile for C/C++ Program
#
# Author: whyglinux (whyglinux AT hotmail DOT com)
# Date: 2006/03/04

# Description:
# The makefile searches in directories for the source files
# with extensions specified in , then compiles the sources
# and finally produces the , the executable file, by linking
# the objectives.

# Usage:
# $ make compile and link the program.
# $ make objs compile only (no linking. Rarely used).
# $ make clean clean the objectives and dependencies.
# $ make cleanall clean the objectives, dependencies and executable.
# $ make rebuild rebuild the program. The same as make clean && make all.
#==============================================================================

## Customizing Section: adjust the following if necessary.
##=============================================================================

# The executable file name.
# It must be specified.
# PROGRAM := a.out # the executable name
PROGRAM :=

# The directories in which source files reside.
# At least one path should be specified.
# SRCDIRS := . # current directory
SRCDIRS :=

# The source file types (headers excluded).
# At least one type should be specified.
# The valid suffixes are among of .c, .C, .cc, .cpp, .CPP, .c++, .cp, or .cxx.
# SRCEXTS := .c # C program
# SRCEXTS := .cpp # C++ program
# SRCEXTS := .c .cpp # C/C++ program
SRCEXTS :=

# The flags used by the cpp (man cpp for more).
# CPPFLAGS := -Wall -Werror # show all warnings and take them as errors
CPPFLAGS :=

# The compiling flags used only for C.
# If it is a C++ program, no need to set these flags.
# If it is a C and C++ merging program, set these flags for the C parts.
CFLAGS :=
CFLAGS +=

# The compiling flags used only for C++.
# If it is a C program, no need to set these flags.
# If it is a C and C++ merging program, set these flags for the C++ parts.
CXXFLAGS :=
CXXFLAGS +=

# The library and the link options ( C and C++ common).
LDFLAGS :=
LDFLAGS +=

## Implict Section: change the following only when necessary.
##=============================================================================
# The C program compiler. Uncomment it to specify yours explicitly.
#CC = gcc

# The C++ program compiler. Uncomment it to specify yours explicitly.
#CXX = g++

# Uncomment the 2 lines to compile C programs as C++ ones.
#CC = $(CXX)
#CFLAGS = $(CXXFLAGS)

# The command used to delete file.
#RM = rm -f

## Stable Section: usually no need to be changed. But you can add more.
##=============================================================================
SHELL = /bin/sh
SOURCES = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS))))
OBJS = $(foreach x,$(SRCEXTS), \
$(patsubst %$(x),%.o,$(filter %$(x),$(SOURCES))))
DEPS = $(patsubst %.o,%.d,$(OBJS))

.PHONY : all objs clean cleanall rebuild

all : $(PROGRAM)

# Rules for creating the dependency files (.d).
#---------------------------------------------------
%.d : %.c
@$(CC) -MM -MD $(CFLAGS) $<

%.d : %.C
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cc
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cpp
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.CPP
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.c++
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cp
@$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cxx
@$(CC) -MM -MD $(CXXFLAGS) $<

# Rules for producing the objects.
#---------------------------------------------------
objs : $(OBJS)

%.o : %.c
$(CC) -c $(CPPFLAGS) $(CFLAGS) $<

%.o : %.C
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cc
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cpp
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.CPP
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.c++
$(CXX -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cp
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cxx
$(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

# Rules for producing the executable.
#----------------------------------------------
$(PROGRAM) : $(OBJS)
ifeq ($(strip $(SRCEXTS)), .c) # C file
$(CC) -o $(PROGRAM) $(OBJS) $(LDFLAGS)
else # C++ file
$(CXX) -o $(PROGRAM) $(OBJS) $(LDFLAGS)
endif

-include $(DEPS)

rebuild: clean all

clean :
@$(RM) *.o *.d

cleanall: clean
@$(RM) $(PROGRAM) $(PROGRAM).exe

### End of the Makefile ## Suggestions are welcome ## All rights reserved ###
###############################################################################

下面是引用原文

C/C++ 通用 Makefile Generic Makefile for C/C++ Program

================================================== Keywords: Makefile, make, Generic, C/C++ Author: whyglinux (whyglinux AT hotmail DOT com) Date: 2006-03-04 ==================================================

本文提供了一个用于对 C/C++ 程序进行编译和连接以产生可执行程序的通用 Makefile。

在使用 Makefile 之前，只需对它进行一些简单的设置即可；而且一经设置，即使以后对源程序文件有所增减一般也不再需要改动 Makefile。因此，即便是一个没有学习过 Makefile 书写规则的人，也可以为自己的 C/C++ 程序快速建立一个可工作的 Makefile。

这个 Makefile 可以在 GNU Make 和 GCC 编译器下正常工作。但是不能保证对于其它版本的 Make 和编译器也能正常工作。

如果你发现了本文中的错误，或者对本文有什么感想或建议，可通过 whyglinux AT hotmail DOT com 邮箱和作者联系。

此 Makefile 的使用方法如下：

1. 程序目录的组织尽量将自己的源程序集中在一个目录中，并且把 Makefile 和源程序放在一起，这样用起来比较方便。当然，也可以将源程序分类存放在不同的目录中。

在程序目录中创建一个名为 Makefile 的文本文件，将后面列出的 Makefile 的内容复制到这个文件中。（注意：在复制的过程中，Makfile 中各命令前面的 Tab 字符有可能被转换成若干个空格。这种情况下需要把 Makefile 命令前面的这些空格替换为一个 Tab。）

将当前工作目录切换到 Makefile 所在的目录。目前，这个 Makefile 只支持在当前目录中的调用，不支持当前目录和 Makefile 所在的路径不是同一目录的情况。

2. 指定可执行文件程序编译和连接成功后产生的可执行文件在 Makefile 中的 PROGRAM 变量中设定。这一项不能为空。为自己程序的可执行文件起一个有意义的名子吧。

3. 指定源程序要编译的源程序由其所在的路径和文件的扩展名两项来确定。由于头文件是通过包含来使用的，所以在这里说的源程序不应包含头文件。

程序所在的路径在 SRCDIRS 中设定。如果源程序分布在不同的目录中，那么需要在 SRCDIRS 中一一指定，并且路径名之间用空格分隔。

在 SRCEXTS 中指定程序中使用的文件类型。C/C++ 程序的扩展名一般有比较固定的几种形式：.c、.C、.cc、.cpp、.CPP、.c++、.cp、或者.cxx（参见 man gcc）。扩展名决定了程序是 C 还是 C++ 程序：.c 是 C 程序，其它扩展名表示 C++ 程序。一般固定使用其中的一种扩展名即可。但是也有可能需要使用多种扩展名，这可以在 SOURCE_EXT 中一一指定，各个扩展名之间用空格分隔。

虽然并不常用，但是 C 程序也可以被作为 C++ 程序编译。这可以通过在 Makefile 中设置 CC = $(CXX) 和 CFLAGS = $(CXXFLAGS) 两项即可实现。

这个 Makefile 支持 C、C++ 以及 C/C++ 混合三种编译方式： * 如果只指定 .c 扩展名，那么这是一个 C 程序，用 $(CC) 表示的编译命令进行编译和连接。 * 如果指定的是除 .c 之外的其它扩展名（如 .cc、.cpp、.cxx 等），那么这是一个 C++ 程序，用 $(CXX) 进行编译和连接。 * 如果既指定了 .c，又指定了其它 C++ 扩展名，那么这是 C/C++ 混合程序，将用 $(CC) 编译其中的 C 程序，用 $(CXX) 编译其中的 C++ 程序，最后再用 $(CXX) 连接程序。

这些工作都是 make 根据在 Makefile 中提供的程序文件类型（扩展名）自动判断进行的，不需要用户干预。

# 指定编译选项编译选项由三部分组成：预处理选项、编译选项以及连接选项，分别由 CPPFLAGS、CFLAGS与CXXFLAGS、LDFLAGS 指定。

CPPFLAGS 选项可参考 C 预处理命令 cpp 的说明，但是注意不能包含 -M 以及和 -M 有关的选项。如果是 C/C++ 混合编程，也可以在这里设置 C/C++ 的一些共同的编译选项。

CFLAGS 和 CXXFLAGS 两个变量通常用来指定编译选项。前者仅仅用于指定 C 程序的编译选项，后者仅仅用于指定 C++ 程序的编译选项。其实也可以在两个变量中指定一些预处理选项（即一些本来应该放在 CPPFLAGS 中的选项），和 CPPFLAGS 并没有明确的界限。

连接选项在 LDFLAGS 中指定。如果只使用 C/C++ 标准库，一般没有必要设置。如果使用了非标准库，应该在这里指定连接需要的选项，如库所在的路径、库名以及其它联接选项。

现在的库一般都提供了一个相应的 .pc 文件来记录使用库所需要的预编译选项、编译选项和连接选项等信息，通过 pkg-config 可以动态提取这些选项。与由用户显式指定各个选项相比，使用 pkg-config 来访问库提供的选项更方便、更具通用性。在后面可以看到一个 GTK+ 程序的例子，其编译和连接选项的指定就是用 pkg-config 实现的。

# 编译和连接上面的各项设置好之后保存 Makefile 文件。执行 make 命令，程序就开始编译了。

命令 make 会根据 Makefile 中设置好的路径和文件类型搜索源程序文件，然后根据文件的类型调用相应的编译命令、使用相应的编译选项对程序进行编译。

编译成功之后程序的连接会自动进行。如果没有错误的话最终会产生程序的可执行文件。

注意：在对程序编译之后，会产生和源程序文件一一对应的 .d 文件。这是表示依赖关系的文件，通过它们 make 决定在源程序文件变动之后要进行哪些更新。为每一个源程序文件建立相应的 .d 文件这也是 GNU Make 推荐的方式。

# Makefile 目标（Targets）下面是关于这个 Makefile 提供的目标以及它所完成的功能：

* make 编译和连接程序。相当于 make all。 * make objs 仅仅编译程序产生 .o 目标文件，不进行连接（一般很少单独使用）。 * make clean 删除编译产生的目标文件和依赖文件。 * make cleanall 删除目标文件、依赖文件以及可执行文件。 * make rebuild 重新编译和连接程序。相当于 make clean && make all。

关于这个 Makefile 的实现原理不准备详细解释了。如果有兴趣的话，可参考文末列出的“参考资料”。

Makefile 的内容如下：

############################################################################### # # Generic Makefile for C/C++ Program # # Author: whyglinux (whyglinux AT hotmail DOT com) # Date: 2006/03/04

# Description: # The makefile searches in directories for the source files # with extensions specified in , then compiles the sources # and finally produces the , the executable file, by linking # the objectives.

# Usage: # $ make compile and link the program. # $ make objs compile only (no linking. Rarely used). # $ make clean clean the objectives and dependencies. # $ make cleanall clean the objectives, dependencies and executable. # $ make rebuild rebuild the program. The same as make clean && make all. #==============================================================================

## Customizing Section: adjust the following if necessary. ##=============================================================================

# The executable file name. # It must be specified. # PROGRAM := a.out # the executable name PROGRAM :=

# The directories in which source files reside. # At least one path should be specified. # SRCDIRS := . # current directory SRCDIRS :=

# The source file types (headers excluded). # At least one type should be specified. # The valid suffixes are among of .c, .C, .cc, .cpp, .CPP, .c++, .cp, or .cxx. # SRCEXTS := .c # C program # SRCEXTS := .cpp # C++ program # SRCEXTS := .c .cpp # C/C++ program SRCEXTS :=

# The flags used by the cpp (man cpp for more). # CPPFLAGS := -Wall -Werror # show all warnings and take them as errors CPPFLAGS :=

# The compiling flags used only for C. # If it is a C++ program, no need to set these flags. # If it is a C and C++ merging program, set these flags for the C parts. CFLAGS := CFLAGS +=

# The compiling flags used only for C++. # If it is a C program, no need to set these flags. # If it is a C and C++ merging program, set these flags for the C++ parts. CXXFLAGS := CXXFLAGS +=

# The library and the link options ( C and C++ common). LDFLAGS := LDFLAGS +=

## Implict Section: change the following only when necessary. ##============================================================================= # The C program compiler. Uncomment it to specify yours explicitly. #CC = gcc

# The C++ program compiler. Uncomment it to specify yours explicitly. #CXX = g++

# Uncomment the 2 lines to compile C programs as C++ ones. #CC = $(CXX) #CFLAGS = $(CXXFLAGS)

# The command used to delete file. #RM = rm -f

## Stable Section: usually no need to be changed. But you can add more. ##============================================================================= SHELL = /bin/sh SOURCES = $(foreach d,$(SRCDIRS),$(wildcard $(addprefix $(d)/*,$(SRCEXTS)))) OBJS = $(foreach x,$(SRCEXTS), \ $(patsubst %$(x),%.o,$(filter %$(x),$(SOURCES)))) DEPS = $(patsubst %.o,%.d,$(OBJS))

.PHONY : all objs clean cleanall rebuild

all : $(PROGRAM)

# Rules for creating the dependency files (.d). #————————————————— %.d : %.c @$(CC) -MM -MD $(CFLAGS) $<

%.d : %.C @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cc @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cpp @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.CPP @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.c++ @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cp @$(CC) -MM -MD $(CXXFLAGS) $<

%.d : %.cxx @$(CC) -MM -MD $(CXXFLAGS) $<

# Rules for producing the objects. #————————————————— objs : $(OBJS)

%.o : %.c $(CC) -c $(CPPFLAGS) $(CFLAGS) $<

%.o : %.C $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cc $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cpp $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.CPP $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.c++ $(CXX -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cp $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

%.o : %.cxx $(CXX) -c $(CPPFLAGS) $(CXXFLAGS) $<

# Rules for producing the executable. #———————————————- $(PROGRAM) : $(OBJS) ifeq ($(strip $(SRCEXTS)), .c) # C file $(CC) -o $(PROGRAM) $(OBJS) $(LDFLAGS) else # C++ file $(CXX) -o $(PROGRAM) $(OBJS) $(LDFLAGS) endif

-include $(DEPS)

rebuild: clean all

clean : @$(RM) *.o *.d

cleanall: clean @$(RM) $(PROGRAM) $(PROGRAM).exe

### End of the Makefile ## Suggestions are welcome ## All rights reserved ### ###############################################################################

下面提供两个例子来具体说明上面 Makefile 的用法。

例一　Hello World 程序

这个程序的功能是输出 Hello, world! 这样一行文字。由 hello.h、hello.c、main.cxx 三个文件组成。前两个文件是 C 程序，后一个是 C++ 程序，因此这是一个 C 和 C++ 混编程序。

/* File name: hello.h * C header file */

#ifndef HELLO_H #define HELLO_H

#ifdef __cplusplus extern “C” { #endif

void print_hello();

#ifdef __cplusplus } #endif

#endif

/* File name: hello.c * C source file. */ #include “hello.h” #include

void print_hello() { puts( “Hello, world!” ); }

/* File name: main.cxx * C++ source file. */ #include “hello.h”

int main() { print_hello();

return 0; }

建立一个新的目录，然后把这三个文件拷贝到目录中，也把 Makefile 文件拷贝到目录中。之后，对 Makefile 的相关项目进行如下设置：

PROGRAM := hello # 设置运行程序名 SRCDIRS := . # 源程序位于当前目录下 SRCEXTS := .c .cxx # 源程序文件有 .c 和 .cxx 两种类型 CFLAGS := -g # 为 C 目标程序包含 GDB 可用的调试信息 CXXFLAGS := -g # 为 C++ 目标程序包含 GDB 可用的调试信息

由于这个简单的程序只使用了 C 标准库的函数（puts），所以对于 CFLAGS 和 CXXFLAGS 没有过多的要求，LDFLAGS 和 CPPFLAGS 选项也无需设置。

经过上面的设置之后，执行 make 命令就可以编译程序了。如果没有错误出现的话，./hello 就可以运行程序了。

如果修改了源程序的话，可以看到只有和修改有关的源文件被编译。也可以再为程序添加新的源文件，只要它们的扩展名是已经在 Makefile 中设置过的，那么就没有必要修改　Makefile。

例二　GTK+ 版 Hello World 程序

这个 GTK+ 2.0 版的 Hello World 程序可以从下面的网址上得到：http://www.gtk.org/tutorial/c58.html#SEC-HELLOWORLD。当然，要编译 GTK+ 程序，还需要你的系统上已经安装好了 GTK+。

跟第一个例子一样，单独创建一个新的目录，把上面网页中提供的程序保存为 main.c 文件。对 Makefile 做如下设置：

PROGRAM := hello # 设置运行程序名 SRCDIRS := . # 源程序位于当前目录下 SRCEXTS := .c # 源程序文件只有 .c 一种类型 CFLAGS := `pkg-config –cflags gtk+-2.0` # CFLAGS LDFLAGS := `pkg-config –libs gtk+-2.0` # LDFLAGS

这是一个 C 程序，所以 CXXFLAGS 没有必要设置——即使被设置了也不会被使用。

编译和连接 GTK+ 库所需要的 CFLAGS 和 LDFLAGS 由 pkg-config 程序自动产生。

现在就可以运行 make 命令编译、./hello 执行这个 GTK+ 程序了。

GCC "-fomit-frame-pointer"编译选项的含义

Thu, 22 Aug 2013 15:52:18 +0800

在 makefile 中看到这个编译选项，不太理解于是查了一下，相关的东西还不多，抄一下放在这里

首先这个文章，http://blog.csdn.net/byzs/article/details/2220461，讲的不错，挺清晰的：

优化你的软件时，发觉"-fomit-frame-pointer"这个选项还是蛮有用的。

GCC手册上面这么说： Don’t keep the frame pointer in a register for functions that don’t need one. This avoids the instructions to save, set up and restore frame pointers; it also makes an extra register available in many functions. It also makes debugging impossible on some machines.

On some machines, such as the VAX, this flag has no effect, because the standard calling sequence automatically handles the frame pointer and nothing is saved by pretending it doesn’t exist. The machine-description macro “FRAME_POINTER_REQUIRED” controls whether a target machine supports this flag.

这里，引入了一个"frame pointer"的概念，什么是"stack frame pointer(SFP)“呢？

我们知道，backtrace是利用堆栈中的信息把函数调用关系层层遍历出来的，其中这里的堆栈信息就是SFP。一般情况下，每一个函数都包含一个堆栈边界指针，也就是说会存在一个栈底和栈顶指针。在X86下，假设堆栈由上往下发展，栈底大地址而栈顶小地址，那么，通常情况下，寄存器ESP为栈顶指针，而EBP就为栈底指针。而EBP和ESP之间的空间就是这个函数的stack frame。 GCC在默认情况下会在每个函数的开始加入一些堆栈设置代码，而在函数退出的时候恢复原来的样子，SFP就是在这个时候设置的。还是看一下这个时候的汇编代码吧 ;-)

环境：X86+Redhat 9.0，gcc 3.2.2

源文件如下：

$ cat test.c void a(unsigned long a, unsigned int b) { unsigned long i; unsigned int j;

        i = a; j = b;

        i++;

        j += 2;

}

默认编译选项： $ gcc -c test.c -o with_SFP.o

反汇编后是这个样子： $ objdump -D with_SFP.o

with_SFP.o:     file format elf32-i386

Disassembly of section .text:

00000000 : 0:   55                      push   %ebp 1:   89 e5                   mov    %esp,%ebp 3:   83 ec 08                sub    $0x8,%esp 6:   8b 45 08                mov    0x8(%ebp),%eax 9:   89 45 fc                mov    %eax,0xfffffffc(%ebp) c:   8b 45 0c                mov    0xc(%ebp),%eax f:   89 45 f8                mov    %eax,0xfffffff8(%ebp) 12:   8d 45 fc                lea    0xfffffffc(%ebp),%eax 15:   ff 00                   incl   (%eax) 17:   8d 45 f8                lea    0xfffffff8(%ebp),%eax 1a:   83 00 02                addl   $0x2,(%eax) 1d:   c9                      leave 1e:   c3                      ret Disassembly of section .data:

可以看到函数ENTER时首先把上一层函数的EBP入栈，设置本函数的EBP，然后会根据临时变量的数量和对齐要求去设置ESP，也就产生了函数的stack frame。我们再看看函数的返回：“leave"指令相当于"mov %ebp,%esp;pop %ebp”,也就是ENTER是两条指令的恢复过程，所以，后面的"ret"指令和"call"指令对应。这里backtrace就可以根据现有函数EBP指针得知上一个函数的EBP—-栈底再往上保存着上一个函数的EBP和EIP，然后就可以得知函数调用的路径。

SFP是可以在编译时候优化掉的，用”-fomit-frame-pointer"选项

编译： $ gcc -fomit-frame-pointer -c test.c -o no_SFP.o

$ objdump -D no_SFP.o

no_SFP.o:     file format elf32-i386

Disassembly of section .text:

00000000 : 0:   83 ec 08                sub    $0x8,%esp 3:   8b 44 24 0c             mov    0xc(%esp,1),%eax 7:   89 44 24 04             mov    %eax,0x4(%esp,1) b:   8b 44 24 10             mov    0x10(%esp,1),%eax f:   89 04 24                mov    %eax,(%esp,1) 12:   8d 44 24 04             lea    0x4(%esp,1),%eax 16:   ff 00                   incl   (%eax) 18:   89 e0                   mov    %esp,%eax 1a:   83 00 02                addl   $0x2,(%eax) 1d:   83 c4 08                add    $0x8,%esp 20:   c3                      ret Disassembly of section .data: 这里把EBP省掉了，ESP兼职了EBP的部分工作（索引临时变量）。显而易见，代码难懂了;-P，代码执行长度缩短了，应该能引起效率的提升。可恶的是，不能用backtrace调试了。

看一下arm下面的情况：含有SFP的版本： $ arm-linux-objdump -D SFP_arm.o

SFP_arm.o :     file format elf32-littlearm

Disassembly of section .text:

00000000 : 0:   e1a0c00d        mov     ip, sp 4:   e92dd800        stmdb   sp!, {fp, ip, lr, pc} 8:   e24cb004        sub     fp, ip, #4      ; 0x4 c:   e24dd010        sub     sp, sp, #16     ; 0x10 10:   e50b0010        str     r0, [fp, -#16] 14:   e50b1014        str     r1, [fp, -#20] 18:   e51b3010        ldr     r3, [fp, -#16] 1c:   e50b3018        str     r3, [fp, -#24] 20:   e51b3014        ldr     r3, [fp, -#20] 24:   e50b301c        str     r3, [fp, -#28] 28:   e51b3018        ldr     r3, [fp, -#24] 2c:   e2833001        add     r3, r3, #1      ; 0x1 30:   e50b3018        str     r3, [fp, -#24] 34:   e51b301c        ldr     r3, [fp, -#28] 38:   e2833002        add     r3, r3, #2      ; 0x2 3c:   e50b301c        str     r3, [fp, -#28] 40:   e91ba800        ldmdb   fp, {fp, sp, pc} Disassembly of section .data:

优化后的版本： $ arm-linux-objdump -D no_SFP_arm.o

no_SFP_arm.o:     file format elf32-littlearm

Disassembly of section .text:

00000000 : 0:   e24dd010        sub     sp, sp, #16     ; 0x10 4:   e58d000c        str     r0, [sp, #12] 8:   e58d1008        str     r1, [sp, #8] c:   e59d300c        ldr     r3, [sp, #12] 10:   e58d3004        str     r3, [sp, #4] 14:   e59d3008        ldr     r3, [sp, #8] 18:   e58d3000        str     r3, [sp] 1c:   e59d3004        ldr     r3, [sp, #4] 20:   e2833001        add     r3, r3, #1      ; 0x1 24:   e58d3004        str     r3, [sp, #4] 28:   e59d3000        ldr     r3, [sp] 2c:   e2833002        add     r3, r3, #2      ; 0x2 30:   e58d3000        str     r3, [sp] 34:   e28dd010        add     sp, sp, #16     ; 0x10 38:   e1a0f00e        mov     pc, lr Disassembly of section .data:

这里，“fp"充当了"EBP"的角色，ESP在X86里面被leave隐含的恢复好了，所以没有显示设置的必要。看起来arm平台上”-fomit-frame-pointer"选项的优化作用更加明显。

然后后面又看到这里，http://zhouzhen1.blogbus.com/logs/10843069.html，也讲到函数调用的压栈过程的 ebp，esp 指针的问题，但是感觉没太看懂：

今天下班前看了一下工作中涉及到的C++程序在VS.net环境中的编译选项。发现其中很多东西对我来说很陌生，公司的手册只是告诉我哪些要怎么设置，但并不提这个参数有什么意义，或者这样设的目的是什么。

刚才上网查了有关omit frame pointer的资料，

http://www.codeproject.com/tips/stackdumper.asp

我们说所谓函数调用反映在汇编层面表现为对栈的操作，而frame pointer指的是一个叫做ebp的寄存器，其中存放该函数的基址。发生函数调用时，调用者首先将函数变量以及返回地址入栈，而后代码指针转入被调用函数，这里首先将调用者的基址（已在调用者开始时存在ebp中）入栈，同时将自己的基址记入ebp，然后修改栈顶指针esp以容纳被调用函数自身的局部变量，函数退出时，将栈顶指针恢复至自己的基址（从ebp中取得），然后将调用者的基址弹出至ebp并返回。

所以说ebp用于记录函数的基址，用于在函数返回时的清栈工作。而在上面的链接中，作者提出利用这个处理过程的汇编代码来寻找栈操作汇编代码。

那么为什么VS.net可以忽略frame pointer？如果忽略的话，函数返回时岂不是不知道自己的基址了，怎么完成退栈呢？网上没人提这个，我想会不会是因为在编译过程中其实已经可以知道这个信息，所以直接把一个立即数赋给esp就可以了？

后面又看到这里，http://stackoverflow.com/questions/1942801/when-should-i-omit-the-frame-pointer，也讲到 ebp 可以减少栈操作：

-fomit-frame-pointer allows one extra register to be available for general-purpose use. I would assume this is really only a big deal on 32-bit x86, which is a bit starved for registers.*

One would expect to see EBP no longer saved and adjusted on every function call, and probably some additional use of EBP in normal code, and fewer stack operations on occasions where EBP gets used as a general-purpose register.

Your code is far too simple to see any benefit from this sort of optimization– you’re not using enough registers. Also, you haven’t turned on the optimizer, which might be necessary to see some of these effects.

* ISA registers, not micro-architecture registers.

而这里，http://stackoverflow.com/questions/14666665/trying-to-understand-gcc-option-fomit-frame-pointer，也讲到了，在简单的上下文环境中，这个选项其实是意义不大的：

Most smaller functions don’t need a frame-pointer - larger functions MAY need one.

It’s really about how well the compiler manages to track how the stack is used, and where things are on the stack (local variables, arguments passed to the current function and arguments being prepared for a function about to be called). I don’t think it’s easy to characterize the functions that need or don’t need a frame-pointer [technically, NO function HAS to have a frame-pointer - it’s more a case of “if the compiler deems it necessary to reduce the complexity of other code”].

I don’t think you should “attempt to make functions not have frame-pointer” as part of your strategy for coding - like I said, simple functions don’t need them, so use -fomit-frame-pointer, and you’ll get one more register available for the register allocator, and save 1-3 instructions on entry/exit to functions. If your function needs a frame-pointer, it’s because the compiler decides that’s a better option than using frame pointer. It’s not a goal to have functions without frame pointer, it’s a goal to have code that works both correctly and fast.

Note that “not having framepointer” should give better performance, but it’s not some magic bullet that gives enormous improvements - particularly not on x86-64, which already has 16 registers to start with. On 32-bit x86, since it only has 8 registers, one of which is stackpointer, and taking up another as the frame-pointer means 25% of register-space is taken. To change that to 12.5% is quite an improvement. Of course, compiling for 64-bit will help quite a lot too.

最后，gnu gcc 的文档这里，http://gcc.gnu.org/onlinedocs/gcc-3.4.4/gcc/Optimize-Options.html，讲到了这个选项的默认配置：

-fomit-frame-pointerDon’t keep the frame pointer in a register for functions that don’t need one. This avoids the instructions to save, set up and restore frame pointers; it also makes an extra register available in many functions. It also makes debugging impossible on some machines.

On some machines, such as the VAX, this flag has no effect, because the standard calling sequence automatically handles the frame pointer and nothing is saved by pretending it doesn’t exist. The machine-description macro FRAME_POINTER_REQUIRED controls whether a target machine supports this flag. See Register Usage.

Enabled at levels -O, -O2, -O3, -Os.

修改函数的返回地址

Wed, 21 Aug 2013 23:28:12 +0800

来看这个代码

#include <stdio.h>

void fun2() {
    printf("haha\n");
}

void fun1(int a) {
    int* ret_addr = (&a)-1;
    *ret_addr = (int)fun2;
}

int main() {
    int a = 3;
    fun1(a);
    return 0;
}

他跑起来之后的输出是这样的：

zrj@vm:~/tmp$ ./a.out 
haha
段错误 (核心已转储)

虽然触发了一个段错误，不过可以看到，还是成功的修改了函数的返回地址了的

其实之前是考虑用函数内部分配栈上变量来获得返回的地址的指针指向的，但是没有成功，可以看下这段代码

#include <stdio.h>

void fun2() {
    printf("haha\n");
}

void fun1(int a) {
    int b = 0;
    int* ret_addr = (&a)-1;
    printf("b+2: %p\nret_addr: %p\n", &b+2, ret_addr);
    *ret_addr = (int)fun2;
}

int main() {
    int a = 3;
    fun1(a);
    return 0;
}

输出如下：

zrj@vm:~/tmp$ ./a.out 
b+2: 0xbff136c0
ret_addr: 0xbff136cc
haha
段错误 (核心已转储)
zrj@vm:~/tmp$ cat main.cpp

可以看到栈上变量 b 和返回地址之间还是有不小的距离的，那么这中间是什么东西呢？还没搞清楚

位运算的一个坑

Tue, 30 Jul 2013 11:32:30 +0800

来看这段代码

#include <stdio.h>

int main() {
    int a = 1, b = 0;
    if (a|b == 0) {
        printf("1\n");
    } else {
        printf("2\n");
    }
    return 0;
}

这段代码想表达的意思是，如果两个 int 都为 0，那么走 if 分支，不然的话，走 else 分支，嗯，大家都是这么想的，实际上，他输出什么呢？

输出 1。

因为位运算的优先级比判等的优先级低。

http://en.cppreference.com/w/cpp/language/operator_precedence

Precedence	Operator	Description	Associativity
1	`::`	Scope resolution	Left-to-right
2	`++` `--`	Suffix/postfix increment and decrement
`()`	Function call
`[]`	Array subscripting
`.`	Element selection by reference
`->`	Element selection through pointer
3	`++` `--`	Prefix increment and decrement	Right-to-left
`+` `−`	Unary plus and minus
`!` `~`	Logical NOT and bitwise NOT
`(_type_)`	Type cast
`*`	Indirection (dereference)
`&`	Address-of
`sizeof`	Size-of
`new`, `new[]`	Dynamic memory allocation
`delete`, `delete[]`	Dynamic memory deallocation
4	`.` `->`	Pointer to member	Left-to-right
5	`*` `/` `%`	Multiplication, division, and remainder
6	`+` `−`	Addition and subtraction
7	`<<` `>>`	Bitwise left shift and right shift
8	`<` `<=`	For relational operators < and ≤ respectively
`>` `>=`	For relational operators > and ≥ respectively
9	`==` `!=`	For relational = and ≠ respectively
10	`&`	Bitwise AND
11	`^`	Bitwise XOR (exclusive or)
12	`\|`	Bitwise OR (inclusive or)
13	`&&`	Logical AND
14	`\|\|`	Logical OR
15	`?:`	Ternary conditional	Right-to-left
`=`	Direct assignment (provided by default for C++ classes)
`+=` `−=`	Assignment by sum and difference
`*=` `/=` `%=`	Assignment by product, quotient, and remainder
`<<=` `>>=`	Assignment by bitwise left shift and right shift
`&=` `^=` `\|=`	Assignment by bitwise AND, XOR, and OR
16	`throw`	Throw operator (for exceptions)
17	`,`	Comma	Left-to-right

使用代码块来缩小变量作用域

Wed, 24 Apr 2013 15:03:46 +0800

今天突发奇想，想到这么一个写法

#include <stdio.h>

int main() {
    char c = 'A';
    {
        int a = 1;
        printf("%d\n", a);
        printf("%c\n", c);
    }
    {
        int a = 2;
        printf("%d\n", a);
        printf("%c\n", c);
    }
    return 0;
}

编译一下，居然能够编译通过，跑一下，得到输出

1
A
2
A

这个东西有什么用呢，说实在，我也没有见过别人有这种写法，我自己也是脑子一抽筋想到的。

最明显的作用就是缩小变量的作用域，可以避免冲突，另外的话，这种用来区分不用作用的代码块，有助于一个长函数中对代码的阅读，不过，这要求两个代码块之间的变量几乎互相独立，真要这样的话，这个长函数干嘛不拆啊，囧。

历史评论

ZRJ (2013-10-11 19:47:05):

突然想到，这种写法，结合 RAII 形式的互斥锁，是可以达到规划临界区的目的的

Linux 多进程监听 socket

Thu, 11 Apr 2013 15:31:17 +0800

首先来看代码

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/wait.h>

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1 ) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        return -1;
    }
    if (listen(sockfd, 20) == -1) {
        perror("listen");
        return -1;
    }
    for (int i = 0; i < 2; i++) {
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork");
        } else if (pid == 0) {
            // child process
            while (1) {
                struct sockaddr_in cli_addr;
                memset(&cli_addr, 0, sizeof(cli_addr));
                socklen_t cli_addr_len = 0;
                int connfd = accept(sockfd, (struct sockaddr*)&cli_addr, &cli_addr_len);
                if (connfd == -1) {
                    perror("accept");
                    return -1;
                }
                char *cli_addr_str = inet_ntoa(cli_addr.sin_addr);
                int cli_addr_port = ntohs(cli_addr.sin_port);
                printf("pid: %d, cli addr: %s:%d\n", getpid(), cli_addr_str, cli_addr_port);
                char buff[4096] = {0};
                if (recv(connfd, buff, sizeof(buff), 0) == -1) {
                    perror("recv");
                    return -1;
                }
                char html_resp[] = "HTTP/1.1 200 OK\r\n\r\nhello";
                if (send(connfd, html_resp, strlen(html_resp), 0) == -1) {
                    perror("send");
                    return -1;
                }
                close(connfd);
            }        
        } else if (pid > 0) {
            // parent process
            printf("forked pid: %d\n", pid);
        }
    }
    while (1) {
        pid_t end_pid = wait(NULL);
        if (end_pid == -1) {
            perror("wait");
            return -1;
        }
        printf("child process %d end\n", end_pid);
    }
    close(sockfd);
    return 0;
}

编译一下

g++ -Wall -g main.cpp -o addrreuse.exe

多次模拟请求

wget http://localhost:8080/123

服务端的输出如下：

forked pid: 23278
forked pid: 23279
pid: 23278, cli addr: 0.0.0.0:0
pid: 23279, cli addr: 0.0.0.0:0
pid: 23278, cli addr: 0.0.0.0:0
pid: 23279, cli addr: 0.0.0.0:0

事实证明，是可以多个进程来 accept 一个 sockfd 的，（好吧，高手当我在说废话就行了），然后注意到有一个东西叫惊群效应，http://blog.csdn.net/chenxinl/article/details/6376895

惊群效应：指一个fd的事件被触发后，等候这个fd的所有线程/进程都被唤醒。低版本的linux内核在accept这边有所谓的“惊群效应”，是指一个链接过来，会把堵塞在accept上的所有子进程都唤醒；但是只有一个子进程都读取到链接，其他子进程唤醒后发现没有数据，继续睡觉去了；这样就产生了大量的进程切换开销。但目前的内核版本已经修复了这个问题，一个链接过来，内核只会唤醒一个子进程出来accept，这样就不用担心惊群效应了。但是对于其他类型的fd，惊群效应还是存在的，而且是必须的；比如多个进程wait在一个pipe的读事件上，有数据过来后，多个进程都会被唤醒，因为内核也不知道这些数据就给一个进程读的，还是每个进程都读一点，这个逻辑是应用层控制的；而accept也相当于一个读事件，但内核确认一个进程接受一个链接就可以了。同理，如果多个子进程把同一个listen的fd添加到各自的epoll_wait中，有链接过来会导致所有的子进程唤醒，这也会导致惊群效应；但这个是应用层面需要解决的问题。关于httpserver惊群效应和如何处理：http://bbs3.chinaunix.net/viewthread.php?action=printable&tid=1676724

但是另外看到这里，http://www.iteye.com/topic/561424

在2.6内核下，内核只会wakeup一个进程。就是说，2.6的内核下面，不会出现惊群的现象。

Linux TCP UDP 混合

Mon, 08 Apr 2013 16:07:14 +0800

基本的思路是这样的：在服务器端，有两个机器，一个对外开启 TCP 监听，然后把监听到的请求内容送到后面的另外一台，或者多台轮询机器上，内网之间使用 UDP，然后等待业务逻辑机器处理完成，这个地方可以做成异步的，然后再返回到用户。

即是这样： client <-TCP-> server_front <-UDP-> server_back

下面来看代码，首先是 server_front 的 demo

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>

#include "struct.h"

int main() {
    int tcpfd = socket(AF_INET, SOCK_STREAM, 0);
    if (tcpfd == -1) {
        perror("tcpfd socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(38080);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(tcpfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("tcpfd bind");
        return -1;
    }
    if (listen(tcpfd, 10) == -1) {
        perror("tcpfd listen");
        return -1;
    }
    
    // udp
    int udpfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (udpfd == -1) {
        perror("udpfd socket");
        return -1;
    }
    struct sockaddr_in udp_serv_addr;
    memset(&udp_serv_addr, 0, sizeof(udp_serv_addr));
    udp_serv_addr.sin_family = AF_INET;
    udp_serv_addr.sin_port = htons(8080);
    if (inet_pton(AF_INET, "10.1.164.18", &udp_serv_addr.sin_addr) <= 0) {
        perror("udpfd inet pton");
        return -1;
    }
    
    while (1) {
        int tcp_conn_fd = accept(tcpfd, NULL, NULL);
        if (tcp_conn_fd == -1) {
            perror("tcpfd accept");
            return -1;
        }
        char buff[2048];
        memset(buff, 0, sizeof(buff));
        int recvn = recv(tcp_conn_fd, buff, sizeof(buff), 0);
        if (recvn == -1) {
            perror("tcpfd recv");
            return -1;
        }
        printf("recv: [%s]\n", buff);
        //char html_resp[] = "HTTP/1.1 200 OK\r\n\r\ntcp udp mix";
        UDP_MSG udp_msg;
        memset(&udp_msg, 0, sizeof(udp_msg));
        strcpy(udp_msg.str1, "HTTP/1.1 200 OK\r\n\r\n");
        strcpy(udp_msg.str2, "send to udp for cat");
        if (sendto(udpfd, &udp_msg, sizeof(udp_msg), 0, (struct sockaddr*)&udp_serv_addr, sizeof(udp_serv_addr)) == -1) {
            perror("udp send to");
            return -1;
        }
        if (recvfrom(udpfd, &udp_msg, sizeof(udp_msg), 0, NULL, NULL) == -1) {
            perror("udp recv from");
            return -1;
        }
        if (send(tcp_conn_fd, udp_msg.cat, strlen(udp_msg.cat), 0) == -1) {
            perror("tcp send");
            return -1;
        }
        close(tcp_conn_fd);
    }
    close(tcpfd);
    return 0;
}

然后是内部的报文格式 struct.h

#ifndef STRUCT_H
#define STRUCT_H

typedef struct _UDP_MSG {
    int add1;
    int add2;
    int sum;
    char str1[128];
    char str2[128];
    char cat[256];
} UDP_MSG;

#endif /* STRUCT_H */

然后是后端的业务逻辑服务器

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_serv();

int main() {
    return udp_serv();
}

int udp_serv() {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(SERV_PORT);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        return -1;
    }

    while (1) {
        struct sockaddr_in cli_addr;
        memset(&cli_addr, 0, sizeof(cli_addr));
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        socklen_t cli_addr_len = sizeof(cli_addr);
        recvfrom(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
        msg.sum = msg.add1 + msg.add2;
        strcpy(msg.cat, msg.str1);
        strcat(msg.cat, msg.str2);
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, cli_addr_len);
    }

    return 0;
}

编译一下，就可以测试了

$ wget http://localhost:38080/123 && nl 123
--16:05:03--  http://localhost:38080/123
           => `123.2'
Resolving localhost... 127.0.0.1
Connecting to localhost|127.0.0.1|:38080... connected.
HTTP request sent, awaiting response... 200 OK
Length: unspecified

    [<=> ] 19            --.--K/s             

16:05:03 (3.62 MB/s) - `123.2' saved [19]

     1	send to udp for cat

期间，server_front 的输出应该是这样的

recv: [GET /123 HTTP/1.0
User-Agent: Wget/1.10.2
Accept: */*
Host: localhost:38080
Connection: Keep-Alive

]

后台业务逻辑服务器的输出应该是这样的

msg.add1 is: 0
msg.add2 is: 0
msg.sum is: 0
msg.str1 is: HTTP/1.1 200 OK


msg.str2 is: send to udp for cat
msg.cat is: HTTP/1.1 200 OK

send to udp for cat

共享内存的读写

Tue, 26 Mar 2013 17:32:22 +0800

首先我们需要一个 shm_com.h

#ifndef _SHM_COM_H_
#define _SHM_COM_H_

#define TEXT_SZ 2048

struct shared_use_st {
    int written_by_you;
    char some_text[TEXT_SZ];
};

#endif /* _SHM_COM_H  */

然后是 shm1.cpp

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

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#include "shm_com.h"

int main() {
    int running = 1;
    void* shared_memory = (void *)0;
    struct shared_use_st* shared_stuff;
    int shmid;

    srand((unsigned int)getpid());
    shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666|IPC_CREAT);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    shared_memory = shmat(shmid, (void *)0, 0);
    if (shared_memory == (void *)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    printf("Memory attached at %X\n", (int)shared_memory);

    shared_stuff = (struct shared_use_st *)shared_memory;
    shared_stuff->written_by_you = 0;
    while (running) {
        if (shared_stuff->written_by_you) {
            printf("You wrote: %s", shared_stuff->some_text);
            sleep(rand() % 4);
            shared_stuff->written_by_you = 0;
            if (strncmp(shared_stuff->some_text, "end", 3) == 0) {
                running = 0;
            }
        }
    }

    if (shmdt(shared_memory) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }

    if (shmctl(shmid, IPC_RMID, 0) == -1) {
        perror("shmctl");
        exit(EXIT_FAILURE);
    }
   
    return 0;
}

然后是 shm2.cpp

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

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>

#include "shm_com.h"

int main() {
    int running = 1;
    void* shared_memory = (void *)0;
    struct shared_use_st* shared_stuff;
    char buffer[TEXT_SZ];
    
    int shmid = shmget((key_t)1234, sizeof(struct shared_use_st), 0666);
    if (shmid == -1) {
        perror("shmget");
        exit(EXIT_FAILURE);
    }

    shared_memory = shmat(shmid, (void *)0, 0);
    if (shared_memory == (void *)-1) {
        perror("shmat");
        exit(EXIT_FAILURE);
    }

    printf("Memory attached at %X\n", (int)shared_memory);

    shared_stuff = (struct shared_use_st *)shared_memory;

    while (running) {
        while (shared_stuff->written_by_you == 1) {
            sleep(1);
            printf("waiting for client...\n");
        }
        printf("Enter some text: ");
        fgets(buffer, TEXT_SZ, stdin);
        strncpy(shared_stuff->some_text, buffer, TEXT_SZ);
        shared_stuff->written_by_you = 1;

        if (strncmp(buffer, "end", 3) == 0) {
            running = 0;
        }
    }

    if (shmdt(shared_memory) == -1) {
        perror("shmdt");
        exit(EXIT_FAILURE);
    }
    
    return 0;
}

编译一下

g++ -g -Wall shm1.cpp -o shm1.exe
g++ -g -Wall shm2.cpp -o shm2.exe

就可以运行了

-——————————————————————-

2013-03-28 20:04:11 update：注意 shmdt 和 shmctl 两种方式结束共享内存是不同的，shmdt 只是当前进程脱离共享内存，不对内存造成其他影响，而 shmctl 方式是删除这片内存，那样的话，其他的进程就再也无法 attach 这片内存了（已经 attach 上的可以继续）用，但是系统会把这片内存标记为 dest

不同服务器端模型在并发请求下的表现差异

Mon, 25 Mar 2013 11:22:04 +0800

一般来说，服务器的模型有下面几种：

单进程单线程
多进程（一个请求对应一个进程，Apache 之类貌似就是这个）
多线程（一个请求对应一个线程，这个挺少见到的）
select / poll
epoll

它们的差别可以看这个，http://www.cnblogs.com/sharra/archive/2010/12/30/1921287.html

因为需要了解底层设备访问的原理，所以惯用高层应用语言的我，需要了解一下Linux的设备访问机制，尤其是处理一组非阻塞IO的原理方法，标准的术语好像是叫多路复用。以下文章部分句子有引用之处，恕没有一一指出出处。对于接触过Linux内核或设备驱动开发的读者，一定清楚poll和select系统调用，以及从2.5版本引入的epoll机制（epoll机制包含三个系统调用）。网上关于它们的文章，有说用法的，甚为详细，更有分析源代码的，又比较深入，且枝节颇多。经过几篇文章的阅读，我把觉得比较核心的东西写下来吧。我的用意是尽可能以简单的概念，比对他们三者的异同。几经查找我才确定下来，poll和select应该被归类为这样的系统调用，它们可以阻塞地同时探测一组支持非阻塞的IO设备，是否有事件发生（如可读，可写，有高优先级的错误输出，出现错误等等），直至某一个设备触发了事件或者超过了指定的等待时间——也就是它们的职责不是做IO，而是帮助调用者寻找当前就绪的设备。同类型的产品是Windows的IOCP，它也是处理多路复用，只是把IO和探测封装在了一起了。准备的知识有两点：1、fd；2、op->poll。在Linux里面，设备都被抽象为文件，一系列的设备文件就有自己独立的虚拟文件系统，所以，设备在系统调用参数中的表示就是file description。fd其实就是一个整数（特别地，标准输入，输出，错误输出分别对应的fd是0，1，2）。与内核打交道的时候，传递整数的fd可以在自己的文件系统中作进一步的检查是否合法，如果只是返回指针就不能这样操作了，毕竟指针是无差别无意义的。通过fd访问file，通过file可以访问其fileOperator，这里面我们要关心的一个fileOp就是poll。因为系统调用poll和select，就是依靠这个文件操作poll实现的。poll文件操作有两个参数，一个是文件本身，一个可以看做是当设备尚未就绪时调用的回调函数，这个函数是把设备自己特有的等待队列传给内核，让内核把当前的进程挂载到其中（因为当设备就绪时，设备就应该去唤醒在自己特有等待队列中的所有节点，这样当前进程就获取了完成的信号了）。poll文件操作返回的必须是一组标准的掩码，其中的各个位指示当前的不同的就绪状态（全0为没有任何事件触发）。再谈谈早期多路复用的版本poll和select。本质而言，poll和select的共同点就是，对全部指定设备做一次poll，当然这往往都是还没有就绪的，那就会通过回调函数把当前进程注册到设备的等待队列，如果所有设备返回的掩码都没有显示任何的事件触发，就去掉回调函数的函数指针，进入有限时的睡眠状态，再恢复和不断做poll，再作有限时的睡眠，直到其中一个设备有事件触发为止。只要有事件触发，系统调用返回，回到用户态，用户就可以对相关的fd作进一步的读或者写操作了。当然，这个时候还不是所有的设备都就绪的喔，那就得不断地poll或者select了，而做一次这样的系统调用都得轮询所有的设备，次数是设备数*（睡眠次数-1），也就是时间复杂度是O（n），还得做几次O（n）呢。可见，对于现在普遍的服务器程序，需要同时并发监听数千个连接，并且连接需要重复使用的情况，poll和select就存在这样的性能瓶颈。另外，数千个设备fd在每次调用时，都需要将其从用户空间复制到内核空间，这里的开销不可忽略。 poll和select放在一起，是因为其机制一致，而参数和数据结构就略有不同。select一次性传入三组作用于不同信道的设备fd，分别是输入，输出和错误异常。各组的fd期待各组所特有的，由代码指定的一组事件，如输入信道期待输入就绪，输入挂起和错误等事件。然后，select就挑选调用者关心的fd做poll文件操作，检测返回的掩码，看看是否有fd所属信道感兴趣的事件，比如看看这个属于输出信道的fd有没有输出就绪等一系列的事件发生，一样地，如果有一个fd发生感兴趣事件就返回调用了。select，为了同时处理三组使用不同的事件判断规则的fd，采用了位图的方式表示，一组一个位图，位长度是当中最大的fd值，上限是1024，三组就是3072，而且这还只是传入的位图，还有一样大小的传出的位图。当fd数越来越多时，所需的存储开销比较大。既然，一组fd处理起来比较粗放，那就各个fd自己准备好了。poll()系统调用是System V的多元I/O解决方案。它有三个参数，第一个是pollfd结构的数组指针，也就是指向一组fd及其相关信息的指针，因为这个结构包含的除了fd，还有期待的事件掩码和返回的事件掩码，实质上就是将select的中的fd，传入和传出参数归到一个结构之下，也不再把fd分为三组，也不再硬性规定fd感兴趣的事件，这由调用者自己设定。这样，不使用位图来组织数据，也就不需要位图的全部遍历了。按照一般队列地遍历，每个fd做poll文件操作，检查返回的掩码是否有期待的事件，以及做是否有挂起和错误的必要性检查，如果有事件触发，就可以返回调用了。回到poll和select的共同点，面对高并发多连接的应用情境，它们显现出原来没有考虑到的不足，虽然poll比起select又有所改进了。除了上述的关于每次调用都需要做一次从用户空间到内核空间的拷贝，还有这样的问题，就是当处于这样的应用情境时，poll和select会不得不多次操作，并且每次操作都很有可能需要多次进入睡眠状态，也就是多次全部轮询fd，我们应该怎么处理一些会出现重复而无意义的操作。这些重复而无意义的操作有：1、从用户到内核空间拷贝，既然长期监视这几个fd，甚至连期待的事件也不会改变，那拷贝无疑就是重复而无意义的，我们可以让内核长期保存所有需要监视的fd甚至期待事件，或者可以再需要时对部分期待事件进行修改；2、将当前线程轮流加入到每个fd对应设备的等待队列，这样做无非是哪一个设备就绪时能够通知进程退出调用，聪明的开发者想到，那就找个“代理”的回调函数，代替当前进程加入fd的等待队列好了（这也是我后来才总结出来，Linux的等待队列，实质上是回调函数队列吧，也可以使用宏来将当前进程“加入”等待队列，其实就是将唤醒当前进程的回调函数加入队列）。这样，像poll系统调用一样，做poll文件操作发现尚未就绪时，它就调用传入的一个回调函数，这是epoll指定的回调函数，它不再像以前的poll系统调用指定的回调函数那样，而是就将那个“代理”的回调函数加入设备的等待队列就好了，这个代理的回调函数就自己乖乖地等待设备就绪时将它唤醒，然后它就把这个设备fd放到一个指定的地方，同时唤醒可能在等待的进程，到这个指定的地方取fd就好了。我们把1和2结合起来就可以这样做了，只拷贝一次fd，一旦确定了fd就可以做poll文件操作，如果有事件当然好啦，马上就把fd放到指定的地方，而通常都是没有的，那就给这个fd的等待队列加一个回调函数，有事件就自动把fd放到指定的地方，当前进程不需要再一个个poll和睡眠等待了。 epoll机制就是这样改进的了。诚然，fd少的时候，当前进程一个个地等问题不大，可是现在和尚多了，方丈就不好管了。以前设备事件触发时，只负责唤醒当前进程就好了，而当前进程也只能傻傻地在poll里面等待或者循环，再来一次poll，也不知道这个由设备提供的poll性能如何，能不能检查出当前进程已经在等待了就立即返回，当然，我也不明白为什么做了一遍的poll之后，去掉回调函数指针了，还得再做，不是说好了会去唤醒进程的吗？现在就让事件触发回调函数多做一步。本来设备还没就绪就调用一个回调函数了，现在再在这个回调函数里面做一个注册另一个回调函数的操作，目的就是使得设备事件触发多走一步，不仅仅是唤醒当前进程，还要把自己的fd放到指定的地方。就像收本子的班长，以前得一个个学生地去问有没有本子，如果没有，它还得等待一段时间而后又继续问，现在好了，只走一次，如果没有本子，班长就告诉大家去那里交本子，当班长想起要取本子，就去那里看看或者等待一定时间后离开，有本子到了就叫醒他，然后取走。这个道理很简单，就是老师和班干们常说的，大家多做一点工作，我的工作就轻松很多了，尤其是需要管理的东西越来越多时。这种机制或者说模式，我想在Java的FutureTask里面应该也会用到的，一堆在线程池里面跑着的线程（当然这是任务，不是线程，接口是Callable，不是Runnable.run，是Callable.call，它是可以返回结果的），谁先做好就应该先处理呀，可是难道得一个个问吗？干脆就谁好了，谁就按照既定的操作暴露自己，这样FutureTask的get方法就可以马上知道当前最先完成的线程了，就可以取此线程返回结果了。 epoll由三个系统调用组成，分别是epoll_create，epoll_ctl和epoll_wait。epoll_create用于创建和初始化一些内部使用的数据结构；epoll_ctl用于添加，删除或者修改指定的fd及其期待的事件，epoll_wait就是用于等待任何先前指定的fd事件。关于epoll内部的数据结构，我就不能详细了解了。

下面就是分别实现一个 demo，然后用 ab 去压力测试，每回都是 10W 个请求，根据不同的并发量测试

单进程单线程

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define BUFFER_SIZE 4096

int tcpSrv(int listen_port);

int main(int argc, char** argv) {
    tcpSrv(8080);
    return 0;
}

int tcpSrv(int listen_port) {
    int listenfd, connfd;
    struct sockaddr_in servaddr;
    char buff[BUFFER_SIZE+1];
    int n;

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(listen_port);

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    if (listen(listenfd, 2048) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    printf("-----waiting for client's request-----\n");
    while (1) {
        if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) == -1) {
            printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        }
        memset(&buff, 0, sizeof(buff));
        recv(connfd, buff, BUFFER_SIZE, 0);
        //printf("recv msg:\n%s\n", buff);
        char resp[] = "HTTP/1.0 200 OK\r\n\r\n<html>hello</html>";
        send(connfd, resp, strlen(resp), 0);
        close(connfd);
    }
    
    close(listenfd);
    return 0;
}

一开始觉得这种简单粗暴的方式肯定不行，结果发现还别说，这东西的处理能力还是可以的，看测试结果

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   7.210 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    13869.50 [#/sec] (mean)
Time per request:       0.072 [ms] (mean)
Time per request:       0.072 [ms] (mean, across all concurrent requests)
Transfer rate:          501.14 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       4
Processing:     0    0   0.0      0       4
Waiting:        0    0   0.0      0       4
Total:          0    0   0.0      0       4

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%      4 (longest request)
linux:~/ab/httpd-2.4.3/support$

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      10
Time taken for tests:   5.498 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    18186.97 [#/sec] (mean)
Time per request:       0.550 [ms] (mean)
Time per request:       0.055 [ms] (mean, across all concurrent requests)
Transfer rate:          657.15 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.1      0       6
Processing:     0    0   0.1      0       6
Waiting:        0    0   0.1      0       6
Total:          0    1   0.1      1       6

Percentage of the requests served within a certain time (ms)
  50%      1
  66%      1
  75%      1
  80%      1
  90%      1
  95%      1
  98%      1
  99%      1
 100%      6 (longest request)
linux:~/ab/httpd-2.4.3/support$

100 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 100 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      100
Time taken for tests:   5.816 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    17194.97 [#/sec] (mean)
Time per request:       5.816 [ms] (mean)
Time per request:       0.058 [ms] (mean, across all concurrent requests)
Transfer rate:          621.30 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    1   0.6      1      11
Processing:     1    5   0.8      5      15
Waiting:        0    2   0.6      2      12
Total:          2    6   0.6      6      15

Percentage of the requests served within a certain time (ms)
  50%      6
  66%      6
  75%      6
  80%      6
  90%      6
  95%      6
  98%      7
  99%      7
 100%     15 (longest request)
linux:~/ab/httpd-2.4.3/support$

150 个并发的时候就不行了

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 150 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
apr_pollset_poll: The timeout specified has expired (70007)
Total of 99956 requests completed
linux:~/ab/httpd-2.4.3/support$

接下来是多进程模型

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define BUFFER_SIZE 4096

int tcpSrv(int listen_port);

int main(int argc, char** argv) {
    tcpSrv(8080);
    return 0;
}

int tcpSrv(int listen_port) {
    int listenfd, connfd;
    struct sockaddr_in servaddr;
    char buff[BUFFER_SIZE+1];
    int n;

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(listen_port);

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    if (listen(listenfd, 2048) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    printf("-----waiting for client's request-----\n");
    while (1) {
        if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) == -1) {
            printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        }
        signal(SIGCHLD, SIG_IGN);
        pid_t pid = fork();
        if (pid < 0) {
            printf("fork error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        } else if (pid == 0) {
            //printf("in child process\n");
            memset(&buff, 0, sizeof(buff));
            recv(connfd, buff, BUFFER_SIZE, 0);
            //printf("recv msg:\n%s\n", buff);
            char resp[] = "HTTP/1.0 200 OK\r\n\r\n<html>hello</html>";
            send(connfd, resp, strlen(resp), 0);
            close(connfd);
            exit(0);
        } else if (pid > 0) {
            //printf("in parent process\n");
            close(connfd);
            continue;
        }
    }
    
    close(listenfd);
    return 0;
}

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   41.408 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    2415.02 [#/sec] (mean)
Time per request:       0.414 [ms] (mean)
Time per request:       0.414 [ms] (mean, across all concurrent requests)
Transfer rate:          87.26 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       0
Processing:     0    0   0.1      0       9
Waiting:        0    0   0.1      0       9
Total:          0    0   0.1      0       9

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%      9 (longest request)
linux:~/ab/httpd-2.4.3/support$

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      10
Time taken for tests:   39.517 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    2530.53 [#/sec] (mean)
Time per request:       3.952 [ms] (mean)
Time per request:       0.395 [ms] (mean, across all concurrent requests)
Transfer rate:          91.44 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       3
Processing:     0    4   0.4      4      64
Waiting:        0    4   0.4      4      64
Total:          1    4   0.4      4      64

Percentage of the requests served within a certain time (ms)
  50%      4
  66%      4
  75%      4
  80%      4
  90%      4
  95%      4
  98%      4
  99%      4
 100%     64 (longest request)
linux:~/ab/httpd-2.4.3/support$

100 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 100 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      100
Time taken for tests:   39.980 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    2501.28 [#/sec] (mean)
Time per request:       39.980 [ms] (mean)
Time per request:       0.400 [ms] (mean, across all concurrent requests)
Transfer rate:          90.38 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.3      0      17
Processing:     0   40   1.7     40     120
Waiting:        0   40   1.7     40     120
Total:          3   40   1.6     40     120

Percentage of the requests served within a certain time (ms)
  50%     40
  66%     40
  75%     41
  80%     41
  90%     41
  95%     42
  98%     43
  99%     44
 100%    120 (longest request)
linux:~/ab/httpd-2.4.3/support$

500 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 500 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      500
Time taken for tests:   63.222 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    1581.72 [#/sec] (mean)
Time per request:       316.112 [ms] (mean)
Time per request:       0.632 [ms] (mean, across all concurrent requests)
Transfer rate:          57.15 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0   38 520.0      0   21004
Processing:     3  208 2942.9     51   60202
Waiting:        0  208 2942.9     51   60202
Total:         24  247 3153.2     51   63206

Percentage of the requests served within a certain time (ms)
  50%     51
  66%     52
  75%     52
  80%     52
  90%     53
  95%     54
  98%     55
  99%     61
 100%  63206 (longest request)
linux:~/ab/httpd-2.4.3/support$

1000 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1000 http://localhost:8080/
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        18 bytes

Concurrency Level:      1000
Time taken for tests:   71.625 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    1396.16 [#/sec] (mean)
Time per request:       716.252 [ms] (mean)
Time per request:       0.716 [ms] (mean, across all concurrent requests)
Transfer rate:          50.45 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0   68 628.8      0   21002
Processing:     1  442 4622.4     51   68587
Waiting:        0  442 4622.3     51   68587
Total:         17  510 4934.8     51   71588

Percentage of the requests served within a certain time (ms)
  50%     51
  66%     52
  75%     52
  80%     52
  90%     54
  95%     55
  98%     59
  99%   4107
 100%  71588 (longest request)
linux:~/ab/httpd-2.4.3/support$

再来是多线程

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define BUFFER_SIZE 4096

int tcpSrv(int listen_port);
void* process_thread(void* sockfd);

int main(int argc, char** argv) {
    tcpSrv(8080);
    return 0;
}

void* process_thread(void* sockfd) {
    //printf("thread created\n");
    int connfd = *((int *)sockfd);
    char buff[BUFFER_SIZE+1];
    memset(&buff, 0, sizeof(buff));
    recv(connfd, buff, BUFFER_SIZE, 0);
    //printf("recv msg:\n%s\n", buff);
    char resp[] = "HTTP/1.0 200 OK\r\n\r\n<html>hello</html>";
    send(connfd, resp, strlen(resp), 0);
    close(connfd);
    //printf("thread about to exit\n");
    pthread_exit(NULL);
}

int tcpSrv(int listen_port) {
    int listenfd, connfd;
    struct sockaddr_in servaddr;

    if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
        printf("create socket error: %s(errno: %d)\n", strerror(errno), errno);
        return -1;
    }

    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(listen_port);

    if (bind(listenfd, (struct sockaddr *)&servaddr, sizeof(servaddr)) == -1) {
        printf("bind socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    if (listen(listenfd, 2048) == -1) {
        printf("listen socket error: %s(errno: %d)\n", strerror(errno), errno);
        close(listenfd);
        return -1;
    }

    printf("-----waiting for client's request-----\n");
    while (1) {
        if ((connfd = accept(listenfd, (struct sockaddr *)NULL, NULL)) == -1) {
            printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
            close(listenfd);
            return -1;
        }
        //printf("main thread about to create thread\n");
        pthread_t tid;
        pthread_attr_t opt;
        pthread_attr_init(&opt);
        pthread_attr_setdetachstate(&opt, PTHREAD_CREATE_DETACHED);
        if (pthread_create(&tid, &opt, process_thread, &connfd) != 0) {
            printf("error line: %d\t", __LINE__);
            perror(__FILE__);
            return -1;
        }
        pthread_attr_destroy(&opt);
        //printf("main thread finish creating thread\n");
    }
    
    close(listenfd);
    return 0;
}

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   7.629 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    13108.37 [#/sec] (mean)
Time per request:       0.076 [ms] (mean)
Time per request:       0.076 [ms] (mean, across all concurrent requests)
Transfer rate:          473.64 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       4
Processing:     0    0   0.1      0      24
Waiting:        0    0   0.1      0      23
Total:          0    0   0.1      0      24

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%     24 (longest request)
linux:~/ab/httpd-2.4.3/support$

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
apr_pollset_poll: The timeout specified has expired (70007)
Total of 99991 requests completed
linux:~/ab/httpd-2.4.3/support$

至于 select 和 poll 就没有写了，直接写 epoll 模型

#include <iostream>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <errno.h>

using namespace std;

#define MAX_LINE 1024
#define OPEN_MAX 100
#define LISTENQ 1024
#define SERV_PORT 8080
#define INFTIM 1000
#define MAX_EVENTS 1024
#define EP_TIMEOUT 500

int tcpSrv(int listen_port);
int set_non_block(int fd);

int main(int argc, char* argv[]) {
    tcpSrv(SERV_PORT);
    return 0;
}

int set_non_block(int fd) {
    int fd_fl = fcntl(fd, F_GETFL); 
    fd_fl |= O_NONBLOCK;
    if (fcntl(fd, F_SETFL, fd_fl) < 0) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        return -1;
    }
    return 0;
}

int tcpSrv(int listen_port) {
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == listenfd) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        return -1;
    }
    set_non_block(listenfd);

    struct epoll_event ev;
    ev.data.fd = listenfd;
    ev.events = EPOLLIN|EPOLLET;
    int epfd = epoll_create(4096);
    epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev);

    struct sockaddr_in serveraddr;
    bzero(&serveraddr, sizeof(serveraddr));
    serveraddr.sin_family = AF_INET;
    char* local_addr = "127.0.0.1";
    inet_aton(local_addr, &(serveraddr.sin_addr));
    serveraddr.sin_port = htons(listen_port);

    if (bind(listenfd, (sockaddr*)&serveraddr, sizeof(serveraddr)) == -1) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        close(listenfd);
        return -1;
    }
    
    if (listen(listenfd, LISTENQ) == -1) {
        printf("%d\n:", __LINE__);perror(__FILE__);
        close(listenfd);
        return -1;
    }

    struct epoll_event events[MAX_EVENTS];
    //struct sockaddr_in clientaddr;
    //socklen_t clilen;
    while (1) {
        int nfds = epoll_wait(epfd, events, MAX_EVENTS, EP_TIMEOUT);
        //printf("events count:%d\n", nfds);
        for (int i=0; i<nfds; i++) {
            if (events[i].data.fd == listenfd) {
                while (1) {
                    int connfd = accept(listenfd, NULL, NULL);
                    if (connfd < 0) {
                        //printf("%d\n:", __LINE__);perror(__FILE__);
                        break;
                    }
                    //char *str_client_addr = inet_ntoa(clientaddr.sin_addr);
                    //cout<<"accept a connection from: "<<str_client_addr<<endl;
                    ev.data.fd = connfd;
                    ev.events = EPOLLIN | EPOLLET;
                    epoll_ctl(epfd, EPOLL_CTL_ADD, connfd, &ev);
                }
            } else if (events[i].events & EPOLLIN) {
                //cout<<"EPOLLIN"<<endl;
                int sockfd = events[i].data.fd;
                if (sockfd < 0) {
                    printf("%d\n:", __LINE__);perror(__FILE__);
                    continue;
                }
                char buffer[MAX_LINE+1];
                memset(buffer, 0, sizeof(buffer));
                read(sockfd, buffer, MAX_LINE);
                //printf("%s\n", buffer);
                set_non_block(sockfd);
                char html_resp[] = "HTTP/1.1 200 OK\r\n\r\n<html>epoll</html>";
                write(sockfd, html_resp, strlen(html_resp));
                epoll_ctl(epfd, EPOLL_CTL_DEL, sockfd, NULL);
                close(sockfd);
            }
        }
    }
    
    return 0;
}

单并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      1
Time taken for tests:   7.474 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    13380.33 [#/sec] (mean)
Time per request:       0.075 [ms] (mean)
Time per request:       0.075 [ms] (mean, across all concurrent requests)
Transfer rate:          483.47 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.0      0       4
Processing:     0    0   0.0      0       5
Waiting:        0    0   0.0      0       5
Total:          0    0   0.0      0       5

Percentage of the requests served within a certain time (ms)
  50%      0
  66%      0
  75%      0
  80%      0
  90%      0
  95%      0
  98%      0
  99%      0
 100%      5 (longest request)

10 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 10 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      10
Time taken for tests:   5.991 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    16691.90 [#/sec] (mean)
Time per request:       0.599 [ms] (mean)
Time per request:       0.060 [ms] (mean, across all concurrent requests)
Transfer rate:          603.13 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.1      0       6
Processing:     0    0   0.1      0       7
Waiting:        0    0   0.1      0       6
Total:          0    1   0.2      1       7

Percentage of the requests served within a certain time (ms)
  50%      1
  66%      1
  75%      1
  80%      1
  90%      1
  95%      1
  98%      1
  99%      1
 100%      7 (longest request)

100 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 100 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      100
Time taken for tests:   6.233 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    16043.99 [#/sec] (mean)
Time per request:       6.233 [ms] (mean)
Time per request:       0.062 [ms] (mean, across all concurrent requests)
Transfer rate:          579.71 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    1   1.0      1       9
Processing:     1    5   0.9      5      12
Waiting:        1    2   0.9      2      10
Total:          2    6   1.4      6      15

Percentage of the requests served within a certain time (ms)
  50%      6
  66%      7
  75%      7
  80%      7
  90%      8
  95%      8
  98%     10
  99%     10
 100%     15 (longest request)

1000 个并发

linux:~/ab/httpd-2.4.3/support$ ./ab -n 100000 -c 1000 http://localhost:8080/123
This is ApacheBench, Version 2.3 <$Revision: 1373084 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient)
Completed 10000 requests
Completed 20000 requests
Completed 30000 requests
Completed 40000 requests
Completed 50000 requests
Completed 60000 requests
Completed 70000 requests
Completed 80000 requests
Completed 90000 requests
Completed 100000 requests
Finished 100000 requests


Server Software:        
Server Hostname:        localhost
Server Port:            8080

Document Path:          /123
Document Length:        18 bytes

Concurrency Level:      1000
Time taken for tests:   7.099 seconds
Complete requests:      100000
Failed requests:        0
Write errors:           0
Total transferred:      3700000 bytes
HTML transferred:       1800000 bytes
Requests per second:    14087.17 [#/sec] (mean)
Time per request:       70.987 [ms] (mean)
Time per request:       0.071 [ms] (mean, across all concurrent requests)
Transfer rate:          509.01 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        1   26 115.1     19    3054
Processing:    16   44   9.7     43      76
Waiting:        1   18   8.0     18      54
Total:         20   70 115.7     65    3103

Percentage of the requests served within a certain time (ms)
  50%     65
  66%     73
  75%     79
  80%     82
  90%     89
  95%     95
  98%    101
  99%    106
 100%   3103 (longest request)
linux:~/ab/httpd-2.4.3/support$

可以看到 epoll 确实是很猛的，这里有一个地方需要注意，我调了两天，就是在 epoll 的 EPOLLIN 事件发生在 listenfd 上的时候，这个时候需要去 accept，这个应该都没有什么问题，但是我一开始只是 accept 了一个，而实际上，这个时候，是可能有多个连接在等待 accept 的，于是就导致了并发能力很不行，正确的做法应该是一直 accept，直到没有东西可以 accept 了，这样才能有并发能力。

二级指针删除单向链表

Mon, 04 Feb 2013 23:22:29 +0800

今晚在这里看到一篇文章，http://coolshell.cn/articles/8990.html，原文给的是代码片段，本着动手实践的原则，另外顺便复习一下链表，写了下代码

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

typedef struct _node {
	int n;
	struct _node *next;
} node;

typedef int (* remove_fn)(node const *n);

node *create_link();
void destory_link(node *head);
void print_link(node *head);
int should_remove(node const *n);
node *remove_if(node *head, remove_fn should_remove);
void remove_if2(node **head, remove_fn should_remove);

int main() {
	node *head = create_link();
	print_link(head);
	//head = remove_if(head, should_remove);
	remove_if2(&head, should_remove);
	print_link(head);
	destory_link(head);
	return 0;
}

node *create_link() {
	node *head = malloc(sizeof(node));
	if (head == NULL) {
		printf("malloc head failed\n");
		return NULL;
	}
	head->n = 0;
	head->next = NULL;

	node *pre = head;
	for (int i=1; i<10; i++) {
		node *cur = malloc(sizeof(node));
		if (cur == NULL) {
			printf("malloc node %d failed\n", i);
			return NULL;
		}
		pre->next = cur;
		cur->n = i;
		cur->next = NULL;
		pre = cur;
	}

	return head;
}

void destory_link(node *head) {
	node *cur = head;
	while (cur) {
		node *next = cur->next;
		free(cur);
		cur = next;
	}
}

void print_link(node *head) {
	node *cur = head;
	while (cur) {
		printf("%d\t", cur->n);
		cur = cur->next;
	}
	printf("\n");
}

int should_remove(node const *n) {
	if (n == NULL) {
		return 0;
	}
	return (n->n)%2 == 0;
}

node *remove_if(node *head, remove_fn should_remove) {
	for (node *pre = NULL, *cur = head; cur;) {
		node * const next = cur->next;
		if (should_remove(cur)) {
			if (pre) {
				pre->next= next;
			} else {
				head = next;
			}
			free(cur);
		} else {
			pre = cur;
		}
		cur = next;
	}
	return head;
}

void remove_if2(node **head, remove_fn should_remove) {
	for (node **cur = head; *cur;) {
		node *entry = *cur;
		if (should_remove(entry)) {
			*cur = entry->next;
			free(entry);
		} else {
			cur = &(entry->next);
		}
	}
}

编译运行一下

zrj@zrj-desktop:~/c$ gcc -g -std=gnu99 link.c && ./a.out
0    1    2    3    4    5    6    7    8    9
1    3    5    7    9

其实道理不复杂，自己多读两遍代码就懂了，不得不承认这种写法确实很巧妙，而且就可读性来说，其实也没有下降多少

signal 在 c99 下的差异

Thu, 31 Jan 2013 10:24:33 +0800

在写一个 minishell 的时候，需要捕捉从键盘输入的 ctrl+c 产生的 SIGINT 信号，转入自己的处理函数，代码大致如下

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

int shell_loop() {
    setup();
    COMBINE_COMMAND cmd;
    while (1) {
        init_cmd(&cmd);
        if (read_cmd(&cmd) == -1) {
            break;
        }
        if (strlen(cmd.cmd_line) == 0) {
            clean_up_cmd(&cmd);
            continue;
        }
        parse_cmd(&cmd);
        // print_cmd(&cmd);
        execute_cmd(&cmd);
        clean_up_cmd(&cmd);
    }
    return 0;
}

void setup() {
    signal(SIGINT, sigint_handler);
    signal(SIGQUIT, SIG_IGN);
}

void sigint_handler(int sig) {
    printf("\n[minishell]$ ");
    fflush(stdout);
}

在 make 编译的时候没有问题，但是调试执行的时候结果一直不对，按下 ctrl+c 之后依然退出了程序，怎么调试都不行，于是索性单独新建了一个文件夹，在里面写了一份测试代码

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

void init2();
void handler(int sig);

int main() {
    signal(SIGINT, handler);
    char line[1024];
    while (fgets(line, 1024, stdin) != NULL) {
        init2();
    }
    return 0;
}

void init2() {
    printf("hello");
    fflush(stdout);
}

void handler(int sig) {
    init2();
}

然后编译执行

zrj@vm:~/c/test$ gcc main.c 
zrj@vm:~/c/test$ ./a.out 

hello
hello
hello^Chello^Chello^Chello
hello
hello
hellozrj@vm:~/c/test$

发现是没有任何问题的，一切都按照预期的方式去跑，于是回头去看原来的代码，但是怎么对比都没有发现哪里出问题，到最后几乎要把原来的代码都差不多注视光了，还是没有找到问题所在，这个时候突然想起 Makefile 来，于是看回原来工程的 Makefile，是这样的

.PHONY:clean
CC=gcc
CFLAGS=-Wall -g -std=c99
BIN=minishell
OBJS=main.o str.o shell.o
$(BIN):$(OBJS)
	$(CC) $(CFLAGS) $^ -o $@
%.o:%.c
	$(CC) $(CFLAGS) -c $< -o $@
clean:
	rm -f *.o $(BIN)

注意到第三行的编译参数中有使用了 c99，于是尝试去掉这个东西，再次编译，报一些语法错，主要是用到这个语法，

for (int i=0; i<count; i++)

，把这些文件暂时从 Makefile 中去掉，再编译，能够通过，再执行，于是就发现没有问题了，信号能够正常的捕捉并处理，于是知道是 c99 的问题

google 搜了一下，找到这里，http://forums.debian.net/viewtopic.php?t=6408

I continue my monologue. Thanks for listening.The solution to my problem seems to be simply the following:

Executive summary: use -std=gnu99 on linux if you need some C99 functions (e.g. strtof) but also want to use functions like sigaction and strtok_r

gcc on linux is stricter than gcc on FreeBSD (or icc on either FreeBSD or linux) concerning standards. gcc -std=c99 on linux means: *only* recognize functions specified in the standard (no sigaction, no strtok_r etc) gcc -std=c99 on FreeBSD or icc -std=c99 on either FreeBSD or linux means recognize functions specified in the standard. This corresponds more or less to -std=gnu99 on linux

PS. This trap seems to be quite common (e.g. discussions on debian-glibc about the “fact” that strtof is completely broken on linux). I would be grateful if somebody could point me to a good overview describing what standards compliance means for various OS/compiler+options/standards combinations.

于是把 c99 改成 gnu99 ，问题得到解决

另外这里也有讨论，http://stackoverflow.com/questions/8288164/signals-c99-vs-gnu99

Use sigaction(2) rather than signal(2).

The Linux man page has this, in particular, in the Portability section:

In the original UNIX systems, when a handler that was established using signal() was invoked by the delivery of a signal, the disposition of the signal would be reset to SIG_DFL, and the system did not block delivery of further instances of the signal. System V also provides these semantics for signal(). This was bad because the signal might be delivered again before the handler had a chance to reestablish itself. Furthermore, rapid deliveries of the same signal could result in recursive invocations of the handler.

BSD improved on this situation by changing the semantics of signal handling (but, unfortunately, silently changed the semantics when establishing a handler with signal()). On BSD, when a signal handler is invoked, the signal disposition is not reset, and further instances of the signal are blocked from being delivered while the handler is executing.

The situation on Linux is as follows:

The kernel’s signal() system call provides System V semantics.

By default, in glibc 2 and later, the signal() wrapper function does not invoke the kernel system call. Instead, it calls sigaction(2) using flags that supply BSD semantics. This default behav‐ ior is provided as long as the _BSD_SOURCE feature test macro is defined. By default, _BSD_SOURCE is defined; it is also implicitly defined if one defines _GNU_SOURCE, and can of course be explic‐ itly defined. On glibc 2 and later, if the _BSD_SOURCE feature test macro is not defined, then signal() provides System V semantics. (The default implicit definition of _BSD_SOURCE is not provided if one invokes gcc(1) in one of its standard modes (-std=xxx or -ansi) or defines various other feature test macros such as _POSIX_SOURCE, _XOPEN_SOURCE, or _SVID_SOURCE; see feature_test_macros(7).)

Using std=gnu99, you’re getting BSD semantics. Using -std=c99, you’re getting System V semantics. So the signal handler is “reinstalled” in one case (BSD), and the signal disposition is reset back to SIG_DFL in the other (System V).

pipe 函数产生的文件描述符

Wed, 30 Jan 2013 15:41:23 +0800

我们知道 pipe 可以产生一对管道，用于两个进程之间的单工通信，今天在接触一个代码的时候，发现他有一个做法：为每个进程都准备读写管道的文件描述符，同时，赋初始值为 0 和 1，然后根据需要，再进行或者不进行 pipe 管道的创建，之后进行一些业务逻辑，在后面，进行一个硬编码的比较：如果该进程的管道文件描述符为 0 或者 1，就不做操作，反之如果不是这两个值，就认为是生成的管道描述符，并调用 close 函数进行关闭。

这自然让人出现一个疑问，那就是 pipe 产生的文件描述符会不会可能刚好就是 0 或者 1 呢，动手实验一下

for (int i = 0; i < 10; ++i)
{
    int fds[2];
    pipe(fds);
    printf("%d\n", fds[0]);
    printf("%d\n", fds[1]);
}

输出是这样的

看来 pipe 在实现的时候就已经有所保留了

==========================================

2013-01-30 15:53:00 update 在查阅资料的时候发现这里，http://www.cnblogs.com/jht/archive/2006/04/04/366086.html

dup,dup2函数

这两个函数的功能是输出的重定向定义这两个函数的头文件是unistd.h，有兴趣的可以自己看看这个头文件包含的内容要提的是这个头文件同时定义了下面三个常量 STDERR_FILENO = 2 标准错误输出 STDIN_FILENO = 0 标准输入 STDOUT_FILENO = 1 标准输出

使用 C 操作 MySQL 时的转义

Thu, 27 Dec 2012 13:57:31 +0800

翻阅了一下文档，C 的 API 操作 MySQL 的时候没有参数化查询的接口，于是就简单的做一个转义，其实照着官方文档，很简单，直接附上代码

#include <stdio.h>
#include <Windows.h>
#include "mysql.h"

#define TMP_SIZE 256
#define T_SIZE 1024
#define QUERY_SIZE 4096

int insert_record() {
	// define consts
	const char db_user[] = "root";
	const char db_pwd[] = "root";
	const char db_host[] = "localhost";
	const char db_name[] = "twitter";
	unsigned int db_port = 3306;

	// define mysql vars
	MYSQL mysql;
	MYSQL_RES *mysql_res;
	MYSQL_ROW mysql_row;
	MYSQL_FIELD *mysql_field;
	char tmp[TMP_SIZE][TMP_SIZE];

	mysql_init(&mysql);
	if (mysql_real_connect(&mysql, db_host, db_user, db_pwd,
		db_name, db_port, NULL, 0) == NULL) {
			printf("connect failed: %s\n", mysql_error(&mysql));
			return -1;
	}
	mysql_set_character_set(&mysql, "utf8");

	FILE *file = fopen(
		"C:/tweets2009-06.txt", "r");
	char t_escape[T_SIZE], t_user[T_SIZE], 
		t_content[T_SIZE], t_time[T_SIZE];
	// read the total count line
	fgets(t_escape, T_SIZE, file);
	printf("%s\n", t_escape);	

	for (long long i=0; i<10000; i++) {
		// time line
		fgets(t_escape, T_SIZE, file);
		mysql_real_escape_string(&mysql, t_time, 
			t_escape+2, strlen(t_escape)-3);
		// user link line
		fgets(t_escape, T_SIZE, file);
		mysql_real_escape_string(&mysql, t_user, 
			t_escape+21, strlen(t_escape)-22);
		// content line
		fgets(t_escape, T_SIZE, file);
		mysql_real_escape_string(&mysql, t_content, 
			t_escape+2, strlen(t_escape)-3);
		// empty line
		fgets(t_escape, T_SIZE, file);

		char query[QUERY_SIZE] = {0};
		sprintf(query,
			"insert into t (user, content, time) \
			values ('%s', '%s', '%s')",
			t_user, t_content, t_time);
		//printf("%s\n", query);
		
		if (mysql_query(&mysql, query) != 0) {
			printf("query failed: %s\n", mysql_error(&mysql));
			mysql_close(&mysql);
			return -1;
		}
	}

	mysql_close(&mysql);
	return 0;
}

int main() {
	insert_record();
	return 0;
}

使用到的函数是这个，http://dev.mysql.com/doc/refman/5.1/zh/apis.html#mysql-real-escape-string

使用 C 操作 MySQL

Thu, 27 Dec 2012 12:40:50 +0800

最近在做一个 twitter 的数据分析，要导一些个数据到数据库中，数据量在亿行这个数量级，由于没什么经验，打算先搞个几百万或者千万行试试，在写导入的时候，由于贪图 PHP 和 MySQL 的无缝配合，所以拿着 PHP 就上了，结果发现效果惨不忍睹，效率完全没法满足需求，于是开始考虑转向 C，在网上搜罗了好一会，C 连接 MySQL 的文章倒是有不少，但是都不怎么清晰明了，直到看到这篇，http://www.cnblogs.com/lovebread/archive/2009/11/24/1609936.html

安装完MySQL之后，将安装目录中的include目录下的libmysql.lib文件拷到VS2008安装目录中的VC\lib\下，然后在项目-选项-c/c++-常规中的附加包含目录以及链接器-常规中的附加库目录中加入“c:\MySQL\include\”，并且在链接器-输入中的附加依赖项内添加“libmysql.lib”，这样即可使编译器找到mysql.h头文件，并可在程序中使用c语言的mysql API来操作数据库。（如果MySQL安装目录中无include目录，可到MySQL官网下载并安装MySQL connector for C，并修改include目录路径）

照着做很快就跑起来了，他的范例代码也很容易改动，稍微修改一下就可以在自己的电脑上运行，但是出于学习，还是自己写了一遍，函数的 API 文档可以参考这里，http://dev.mysql.com/doc/refman/5.1/zh/apis.html#mysql-store-result

#include
#include
#include "mysql.h"

#define TMP_SIZE 256

int select_record() {
	// define consts
	const char db_user[] = "root";
	const char db_pwd[] = "root";
	const char db_host[] = "localhost";
	const char db_name[] = "t";
	unsigned int db_port = 3306;

	// define mysql vars
	MYSQL mysql;
	MYSQL_RES *mysql_res;
	MYSQL_ROW mysql_row;
	MYSQL_FIELD *mysql_field;
	char tmp[TMP_SIZE][TMP_SIZE];

	mysql_init(&mysql);
	if (mysql_real_connect(&mysql, db_host, db_user, db_pwd,
		db_name, db_port, NULL, 0) == NULL) {
		printf("connect failed: %s\n", mysql_error(&mysql));
		return -1;
	}
	mysql_query(&mysql, "set names gbk");

	if (mysql_query(&mysql, "select * from user") != 0) {
		printf("query failed: %s\n", mysql_error(&mysql));
		mysql_close(&mysql);
		return -1;
	}
	mysql_res = mysql_store_result(&mysql);
	if (mysql_res == NULL) {
		printf("store result failed: %s\n", mysql_error(&mysql));
		mysql_close(&mysql);
		return -1;
	}
	printf("number of results: %d\n", mysql_num_rows(mysql_res));
	for (int i=0; mysql_field=mysql_fetch_field(mysql_res); i++) {
		printf("%s\n", mysql_field->name);
	}
	printf("====================\n");
	int num_of_fields = mysql_num_fields(mysql_res);
	while (mysql_row = mysql_fetch_row(mysql_res)) {
		for (int i=0; i<num_of_fields; i++) {
			printf("%s\n", mysql_row[i]);
		}
		printf("====================\n");
	}

	mysql_free_result(mysql_res);
	mysql_close(&mysql);
	return 0;
}

int main() {
	select_record();
	return 0;
}

输出如下

number of results: 6
id
email
name
password
avatar
time
====================
1
zrj
ZRJ
455ba221ff5d2d04e84caef24a06fafc
zrj.png
2012-11-21 21:52:30
====================
2
liang
梁斌penny
455ba221ff5d2d04e84caef24a06fafc
liang.jpg
2012-11-21 22:50:24
====================
3
1
1
5469a7c15898d73fedbada90ec8d051c
default.jpg
2012-11-21 23:55:23
====================
4
11
11
39fff158104571897b03f753cf073a42
default.jpg
2012-11-23 21:31:30
====================
5
111
111
e2f95e29a93bb6a45aec242a19cbe62d
default.jpg
2012-11-23 21:32:29
====================
6
1111
1111
8a32f7eaaa2f1f803fea771e9b5d7aa0
default.jpg
2012-11-23 21:32:38
====================

说下自己走的一些弯路，首先需要注意的是，那个 mysql 目录下的 include 文件夹，这个是需要一个典型安装的 mysql 才有的，我在集成的 WAMP 中找了找，没有找到这个文件夹，另外就是在 #include “mysql.h” 之前需要先 #include <Windows.h>，不然会报这个错误

错误	1	error C2146: 语法错误 : 缺少“;”(在标识符“fd”的前面)	c:\program files\mysql\mysql server 5.5\include\mysql_com.h	291	cpp_mysql
错误	2	error C4430: 缺少类型说明符 - 假定为 int。注意: C++ 不支持默认 int	c:\program files\mysql\mysql server 5.5\include\mysql_com.h	291	cpp_mysql
错误	3	error C4430: 缺少类型说明符 - 假定为 int。注意: C++ 不支持默认 int	c:\program files\mysql\mysql server 5.5\include\mysql_com.h	291	cpp_mysql
错误	4	error C2065: “SOCKET”: 未声明的标识符	c:\program files\mysql\mysql server 5.5\include\mysql_com.h	470	cpp_mysql
错误	5	error C2146: 语法错误 : 缺少“)”(在标识符“s”的前面)	c:\program files\mysql\mysql server 5.5\include\mysql_com.h	470	cpp_mysql
错误	6	error C2059: 语法错误 : “)”	c:\program files\mysql\mysql server 5.5\include\mysql_com.h	471	cpp_mysql

字符串转浮点数

Sun, 14 Oct 2012 18:59:17 +0800

今天看到一个题，让把字符串转成浮点数，列了一下，需要注意的应该就是这几点

前导空白字符
符号位
前导零

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

double a2f(char *str) {
	// leading space
	while (*str==' ' || *str=='t') {
		str++;
	}

	// judge sign
	int sign = 1;
	if (*str == '-') {
		sign = -1;
		str++;
	} else if (*str=='+') {
		sign = 1;
		str++;
	} else if (*str>='0' && *str<='9') {
		sign = 1;
	} else {
		// exception
		return 0;
	}

	// leading zero
	while (*str == '0') {
		str++;
	}

	int integer=0, decimals=0, e=0;
	int point_found = 0;
	for (; *str!='\0'; str++) {
		if (*str>='0' && *str<='9') {
			if ( ! point_found) {
				integer = integer*10 + (*str-'0');
			} else {
				decimals = decimals*10 + (*str-'0');
				e++;
			}
		} else if (*str == '.') {
			if ( ! point_found) {
				point_found = 1;
			} else {
				// exception
				return 0;
			}
		} else {
			// exception
			return 0;
		}
	}

	return sign*(integer+decimals*pow(10, e*-1.0));
}

int main() {
	printf("%lfn", a2f("-000123.45600"));
	return 0;
}

==================================

2012-10-14 19:18:25 update 哦，对了，上面的代码没有考虑浮点溢出

字符串距离

Sat, 13 Oct 2012 18:26:16 +0800

今天见到一个题，让求两个字符串之间的距离，隐约记得之前在 php 中用过这个的现成函数，当时还查了一下原理，是一个俄罗斯的人搞的一个算法，原理是用矩阵，于是就往矩阵上去想，结果没想出来，后来听同学说那是个 dp，想想也是，唉，思路狭隘了

参考这里，http://www.java3z.com/cwbwebhome/article/article5/51329.html?id=4197，写了一个矩阵的版本，写的时候注意一下二维数组的操作

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

inline int min(int a, int b, int c) {
	if (a<=b && a<=c) {
		return a;
	} else if (b<=a && b<=c) {
		return b;
	} else {
		return c;
	}
}

int ld(char *str1, char *str2) {
	int len1=strlen(str1), len2=strlen(str2);
	if (len1 == 0) {
		return len2;
	}
	if (len2 == 0) {
		return len1;
	}
	int **d;

	// create 2d array
	d = new int*[len1+1];
	for (int i=0; i<len1+1; i++) {
		d[i] = new int[len2+1];
	}

	// init 2d array
	for (int i=0; i<len1+1; i++) {
		d[i][0] = i;
	}
	for (int i=0; i<len2+1; i++) {
		d[0][i] = i;
	}

	// Levenshtein distance
	for (int i=1; i<=len1; i++) {
		for (int j=1; j<=len2; j++) {
			int is_diff = 0;
			if (str1[i-1] == str2[j-1]) {
				is_diff = 0;
			} else {
				is_diff = 1;
			}
			d[i][j] = min(d[i-1][j]+1, d[i][j-1]+1, d[i-1][j-1]+is_diff);
		}
	}
	int ans = d[len1][len2];

	// delete 2d array
	for (int i=0; i<len1+1; i++) {
		delete[] d[i];
	}
	delete[] d;
	d = NULL;

	return ans;
}

int main() {
	char str1[] = "bambol";
	char str2[] = "umbo";
	printf("%dn", ld(str1, str2));
	return 0;
}

可以看到说是矩阵其实还是有 dp 的影子的

字符串反转

Sat, 13 Oct 2012 17:13:39 +0800

今天遇到一个题，让反转字符串，简单题，注意下细节就好了

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

char *str_reverse(char *str) {
	if (str == NULL) {
		return NULL;
	}
	for (char *left=str, *right=str+strlen(str)-1;
		left<right; left++, right--) {
		char tmp = *left;
		*left = *right;
		*right = tmp;
	}
	return str;
}

int main() {
	char str[] = "123456";
	printf("%sn", str_reverse(str));
	return 0;
}

根据字符表穷举密码

Sat, 13 Oct 2012 17:04:51 +0800

今天遇到一个题，要求根据 a-z0-9 这些字符穷举出所有的可能的密码，搞了搞，代码如下

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

#define PWD_LEN (3)

char table[] = "abcdefghijklmnopqrstuvwxyz0123456789";
int table_len = strlen(table);

void f(char pwd[], int curr) {
	if (curr == PWD_LEN) {
		printf("%sn", pwd);
	} else {
		for (int i=0; i<table_len; i++)	{
			pwd[curr] = table[i];
			f(pwd, curr+1);
		}
	}
}

int main() {
	char pwd[PWD_LEN+1];
	pwd[PWD_LEN] = '\0';
	f(pwd, 0);
	return 0;
}

输出就不贴了，太长了

斐波那契数列

Thu, 11 Oct 2012 11:13:00 +0800

见到一个题，让算斐波那契数列的第 n 项，手工推通项没推出来，记忆化递归如下

#include <stdio.h>

#define MAX 1024

int F[MAX] = {0};

int f(int n) {
	if (F[n] != 0) {
		return F[n];
	}
	F[n] = f(n-1) + f(n-2);
	return F[n];
}

int calc_f(int n) {
	if (n <= 0) {
		return -1;
	}
	F[1] = F[2] = 1;
	return f(n);
}

int main() {
	int n;
	while (EOF != scanf("%d", &n)) {
		printf("%dn", calc_f(n));
	}
	return 0;
}

输入输出

10
55

后来想起来一个非递归的 O(n) 方法

#include <stdio.h>

int f(int n) {
	if (n <= 0) {
		return -1;
	}
	if (n==1 || n==2) {
		return 1;
	}
	int a = 1;
	int b = 1;
	n -= 2;
	while (1)
	{
		a = a + b;
		if (--n <= 0)
		{
			return a;
		}
		b = a + b;
		if (--n <= 0)
		{
			return b;
		}
	}
}

int main() {
	int n;
	while (EOF != scanf("%d", &n)) {
		printf("%dn", f(n));
	}
	return 0;
}

最后耍赖上网看通项，http://en.wikipedia.org/wiki/Fibonacci_number，通项是

注意一下浮点转整型的向下取整，于是得到代码如下

#include <stdio.h>
#include <math.h>

int f(int n) {
	double q_5 = sqrt(5.0);
	double ans = (1/q_5)*pow((1+q_5)/2, n)-(1/q_5)*pow((1-q_5)/2, n);
	return ans+0.5;
}

int main() {
	int n;
	while (EOF != scanf("%d", &n)) {
		printf("%dn", f(n));
	}
	return 0;
}

果然通项公式是第一生产力啊。。

创建一个指定大小的空白文件

Fri, 05 Oct 2012 17:09:08 +0800

这两天在做多线程下载文件的时候，遇到一个问题，需要在下载文件之前，新建一个同等大小的空白文件出来，好往里面写

#include <stdio.h>

int main() {
    FILE *fp = fopen("empty_file", "wb");
    fseek(fp, 2*1024-1, SEEK_SET);
    char end = EOF;
    fwrite(&end, sizeof(char), sizeof(end), fp);
    fclose(fp);
    return 0;
}

需要注意的是，必须用二进制的读写才能达到目的，使用字符的读写是不行的

struct 传参改变内容

Fri, 05 Oct 2012 10:48:23 +0800

今天想到一个问题，就是 struct 的传参和数组的传参的区别，先看代码

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

struct d {
    int n;
    char str[100];
};

void chg(struct d *a) {
    a->n = 1;
    strcpy(a->str, "changing");
    printf("%dn", a->n);
    printf("%sn", a->str);
}

void chg_arr(char str[]) {
    strcpy(str, "changing arr");
    printf("%sn", str);
}

int main() {
    struct d a;
    a.n = 2;
    strcpy(a.str, "before change");
    printf("%dn", a.n);
    printf("%sn", a.str);
    chg(&a);
    strcpy(a.str, "after change");
    printf("%dn", a.n);
    printf("%sn", a.str);

    char str[100] = "before arr change";
    printf("%sn", str);
    chg_arr(str);
    printf("%sn", str);
    return 0;
}

输出如下

2
before change
1
changing
1
after change
before arr change
changing arr
changing arr

数组传参那段好理解，实参进入函数退化成指针，指向同一片内存，所以自然就改变了内容，但是 struct 那段有点意思，包在结构体里面的数组，在传参的时候却是被复制了一份，这其实意味着在某些场合可以把数组包在结构体里面传来传去吧

=========================================

2012-10-07 15:39:00 uodate 上面的代码贴错了，在 lan 同学的指正下，修改如下

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

struct d {
	int n;
	char str[100];
};

void chg(struct d a) {
	a.n = 1;
	strcpy(a.str, "changing");
	printf("%dn", a.n);
	printf("%sn", a.str);
}

void chg_arr(char str[]) {
	strcpy(str, "changing arr");
	printf("%sn", str);
}

int main() {
	struct d a;
	a.n = 2;
	strcpy(a.str, "before change");
	printf("%dn", a.n);
	printf("%sn", a.str);
	chg(a);
	strcpy(a.str, "after change");
	printf("%dn", a.n);
	printf("%sn", a.str);

	char str[100] = "before arr change";
	printf("%sn", str);
	chg_arr(str);
	printf("%sn", str);
	return 0;
}

输出

2
before change
1
changing
2
after change
before arr change
changing arr
changing arr

这个才是达到了传一个结构体会在传参的时候复制一份的效果

历史评论

lan (2012-10-07 11:39:26):

那个结构体里的数组没复制一份啊。三次打印不一样是因为你复值过三次啊。如果结构体传值的话，倒是可以复制一份数组的

ZRJ (2012-10-07 15:43:32):

嗯嗯，修改过来了，之前测试完传值之后又试了一下传指针，结果最后就把传指针的代码贴上来，贴串了。。囧。。

linux 下 fork 后的文件资源处理问题

Tue, 02 Oct 2012 16:47:32 +0800

我们都知道 linux 下 fork 一个子进程出来，他能够继承父进程的文件资源，网络资源等，也从父进程那里拷贝了代码段，数据段，缓冲区等等到自己这里有了新的一份，那么，如果父子进程对于打开的文件资源操作不同，会是怎样的结果呢，先看正常的使用代码

#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv) {
    FILE *fp;
    if ((fp=fopen("test.out", "w+")) == NULL) {
        printf("open file failedn");
        return -1;
    }
    fprintf(fp, "hello worldn");

    pid_t fpid;
    fpid = fork();
    if (fpid < 0) {
        printf("error in forkn");
        return -1;
    } else if (fpid == 0) {
        // in son process
        fprintf(fp, "from son processn");
    } else {
        // in father process
        fprintf(fp, "from father processn");
    }

    fprintf(fp, "donen");

    fclose(fp);
    return 0;
}

这份代码可以生成以下的文件

hello world
from father process
done
hello world
from son process
done

需要注意的是第 4 行和第 6 行，多了一个 hello world 和 done

那么，接下来试试在父进程中关掉文件句柄

一开始，我是这样尝试着关闭的

#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv) {
    FILE *fp;
    if ((fp=fopen("test.out", "w+")) == NULL) {
        printf("open file failedn");
        return -1;
    }
    fprintf(fp, "hello worldn");

    pid_t fpid;
    fpid = fork();
    if (fpid < 0) {
        printf("error in forkn");
        return -1;
    } else if (fpid == 0) {
        // in son process
        fprintf(fp, "from son processn");
    } else {
        // in father process
        fprintf(fp, "from father processn");
        if (fp != NULL) {
            fclose(fp);
        }
    }

    fprintf(fp, "donen");

    if (fp != NULL) {
        fclose(fp);
    }

    return 0;
}

跑起来报

*** glibc detected *** ./fork: double free or corruption (top): 0x092fe008 ***
======= Backtrace: =========
/lib/i386-linux-gnu/libc.so.6(+0x73e42)[0xb7699e42]
/lib/i386-linux-gnu/libc.so.6(fclose+0x154)[0xb7689384]
./fork[0x80485dd]
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf3)[0xb763f4d3]
./fork[0x8048421]
======= Memory map: ========
08048000-08049000 r-xp 00000000 08:01 1063761    /home/zrj/c/fork/fork
08049000-0804a000 r--p 00000000 08:01 1063761    /home/zrj/c/fork/fork
0804a000-0804b000 rw-p 00001000 08:01 1063761    /home/zrj/c/fork/fork
092fe000-0931f000 rw-p 00000000 00:00 0          [heap]
b75f7000-b7613000 r-xp 00000000 08:01 1049526    /lib/i386-linux-gnu/libgcc_s.so.1
b7613000-b7614000 r--p 0001b000 08:01 1049526    /lib/i386-linux-gnu/libgcc_s.so.1
b7614000-b7615000 rw-p 0001c000 08:01 1049526    /lib/i386-linux-gnu/libgcc_s.so.1
b7625000-b7626000 rw-p 00000000 00:00 0
b7626000-b77c5000 r-xp 00000000 08:01 1049505    /lib/i386-linux-gnu/libc-2.15.so
b77c5000-b77c7000 r--p 0019f000 08:01 1049505    /lib/i386-linux-gnu/libc-2.15.so
b77c7000-b77c8000 rw-p 001a1000 08:01 1049505    /lib/i386-linux-gnu/libc-2.15.so
b77c8000-b77cb000 rw-p 00000000 00:00 0
b77da000-b77dd000 rw-p 00000000 00:00 0
b77dd000-b77de000 r-xp 00000000 00:00 0          [vdso]
b77de000-b77fe000 r-xp 00000000 08:01 1049485    /lib/i386-linux-gnu/ld-2.15.so
b77fe000-b77ff000 r--p 0001f000 08:01 1049485    /lib/i386-linux-gnu/ld-2.15.so
b77ff000-b7800000 rw-p 00020000 08:01 1049485    /lib/i386-linux-gnu/ld-2.15.so
bf940000-bf961000 rw-p 00000000 00:00 0          [stack]
已放弃 (核心已转储)

既然他说 double free，那就试试只 free 一次，改成这样后可以正常运行

#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv) {
    FILE *fp;
    if ((fp=fopen("test.out", "w+")) == NULL) {
        printf("open file failedn");
        return -1;
    }
    fprintf(fp, "hello worldn");

    pid_t fpid;
    fpid = fork();
    if (fpid < 0) {
        printf("error in forkn");
        return -1;
    } else if (fpid == 0) {
        // in son process
        fprintf(fp, "from son processn");
    } else {
        // in father process
        fprintf(fp, "from father processn");
        if (fp != NULL) {
            fclose(fp);
        }
    }

    fprintf(fp, "donen");

    return 0;
}

结果是

hello world
from father process
hello world
from son process
done

从结果看，父进程关闭文件句柄，对于子进程应该是没有影响的。背后的原因，不知道是否与 copy-on-write 有关。

============================================

update：上面的第一次 fclose 之前虽然有判空，但是在 fclose 之后没有置空，典型的野指针问题，那么试试该改成这样？

#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv) {
    FILE *fp;
    if ((fp=fopen("test.out", "w+")) == NULL) {
        printf("open file failedn");
        return -1;
    }
    fprintf(fp, "hello worldn");

    pid_t fpid;
    fpid = fork();
    if (fpid < 0) {
        printf("error in forkn");
        return -1;
    } else if (fpid == 0) {
        // in son process
        fprintf(fp, "from son processn");
    } else {
        // in father process
        fprintf(fp, "from father processn");
        if (fp != NULL) {
            fclose(fp);
            fp = NULL;
        }
    }

    fprintf(fp, "donen");

    if (fp != NULL) {
        fclose(fp);
        fp = NULL;
    }

    return 0;
}

结果直接段错误

段错误 (核心已转储)

===============================================

update 最开始的那份代码中，hello world 出现了两次，这个其实是缓冲区引起的，具体的解释可以看这篇文章，http://coolshell.cn/articles/7965.html，改成这样之后

#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv) {
    FILE *fp;
    if ((fp=fopen("test.out", "w+")) == NULL) {
        printf("open file failedn");
        return -1;
    }
    fprintf(fp, "hello world, %dn", getpid());
    fflush(fp);

    pid_t fpid;
    fpid = fork();
    if (fpid < 0) {
        printf("error in forkn");
        return -1;
    } else if (fpid == 0) {
        // in son process
        fprintf(fp, "from son processn");
        fflush(fp);
    } else {
        // in father process
        fprintf(fp, "from father processn");
        fflush(fp);
    }

    fprintf(fp, "donen");
    fflush(fp);

    return 0;
}

输出变成这样

hello world, 13047
from father process
done
from son process
done

这就符合预期了

printf 一定需要 stdio.h 吗

Sun, 30 Sep 2012 09:01:32 +0800

刚刚看到一个范例代码，调用了 printf 函数，但是却没有包含 stdio.h 的头文件，这种写法第一反应就应该是不对的啊，本着动手实验的原则，试了一下

zrj@vm:~/c/test$ cat test.c
int main() {
    printf("hello worldn");
    return 0;
}
zrj@vm:~/c/test$ gcc -o test test.c
test.c: 在函数‘main’中:
test.c:2:5: 警告： 隐式声明与内建函数‘printf’不兼容 [默认启用]
zrj@vm:~/c/test$ ./test
hello world

发现确实是可以的，gcc 在编译的时候给了一个警告，但是能够正常的生成可执行文件，而且也能正常的运行出结果，找了一下，在这里，http://wiki.ubuntu.org.cn/Gcchowto，找到解释

链接外部库库是预编译的目标文件(object files)的集合，它们可被链接进程序。静态库以后缀为‘.a’的特殊的存档文件(archive file)存储。

标准系统库可在目录 /usr/lib 与 /lib 中找到。比如，在类 Unix 系统中 C 语言的数学库一般存储为文件 /usr/lib/libm.a。该库中函数的原型声明在头文件 /usr/include/math.h 中。C 标准库本身存储为 /usr/lib/libc.a，它包含 ANSI/ISO C 标准指定的函数，比如‘printf’。对每一个 C 程序来说，libc.a 都默认被链接。

============================================

2012-10-05 14:27:11 update 在这里，http://zhidao.baidu.com/question/341065125.html?seed=0，有更好的解释

由于编译器在处理函数调用代码时没有找到函数原型，只好根据函数调用代码做隐式声明. 为什么编译器在处理函数调用代码时需要有函数原型？因为必须知道参数的类型和个数以及返回值的类型才知道生成什么样的指令。为什么隐式声明靠不住呢？因为隐式声明是从函数调用代码推导而来的，而事实上函数定义的形参类型可能跟函数调用代码传的实参类型并不一致，如果函数定义带有可变参数（例如printf），那么从函数调用代码也看不出来这个函数带有可变参数，另外，从函数调用代码也看不出来返回值应该是什么类型，所以隐式声明只能规定返回值都是int型的。既然隐式声明靠不住，那编译器为什么不自己去找函数定义，而非要让我们在调用之前写函数原型呢？因为编译器往往不知道去哪里找函数定义.

找出第一个不重复的字母

Mon, 24 Sep 2012 20:01:01 +0800

今天笔试，遇到一个题目要找出一个字符串中第一个不重复的字母，简单写了一下

#include <stdio.h>

void find(const char *str, char *result)
{
	int count[128]={0}, pos[128]={0};
	for (int i=0; str[i]!='\0'; i++)
	{
		int ascii = (int)(str[i]);
		count[ascii]++;
		if (pos[ascii] == 0)
		{
			pos[ascii] = i;
		}
	}
	int min = 99999;
	for (int i=0; i<128; i++)
	{
		if (count[i] == 1 && pos[i]<min)
		{
			*result = (char)i;
			min = pos[i];
		}
	}
}

int main()
{
	char *str = "teeter";
	char result;
	find(str, &result);
	printf("%cn", result);
	return 0;
}

子数组最大和

Mon, 24 Sep 2012 10:16:00 +0800

昨天笔试看到一个求子数组最大和，参考这里，http://blog.csdn.net/v_JULY_v/article/details/6444021，写了一下，复杂度 O(n)

#include <stdio.h>

int max_sum(int *a, int n)
{
	int max = a[0];
	int sum = 0;
	for (int i=0; i<n; i++)
	{
		if (sum < 0)
		{
			sum = a[i];
		}
		else
		{
			sum += a[i];
		}
		if (sum > max)
		{
			max = sum;
		}
	}
	return max;
}

int main()
{
	int a[] = {1, -2, 3, 10, -4, 7, 2, -5};
	printf("%dn", max_sum(a, sizeof(a)/sizeof(int)));
}

出栈次序问题

Mon, 24 Sep 2012 08:14:43 +0800

昨天笔试，见到一个题

一个栈(无穷大)的进栈序列为1,2,3,..n,有多少个不同的出栈序列?

写代码模拟的结果如下

#include <iostream>
#include <stack>
#include <queue>
#include <set>

using namespace std;

set<queue<int>> total;

void print(queue<int> q)
{
	total.insert(q);
	while ( ! q.empty())
	{
		printf("%d ", q.front());
		q.pop();
	}
	printf("n");
}

void push(stack<int> s, int max, int n, queue<int> q)
{
	if (n > max)
	{
		while( ! s.empty())
		{
			q.push(s.top());
			s.pop();
		}
		print(q);
	}
	else
	{
		// 压栈不弹
		s.push(n);
		push(s, max, n+1, q);
		s.pop();

		// 压栈并弹
		s.push(n);
		int size = s.size();
		for (int i=0; i<size; i++)
		{
			q.push(s.top());
			s.pop();
			push(s, max, n+1, q);
		}
	}
}

int main()
{
	int n;
	while (cin>>n && n!=0)
	{
		stack<int> s;
		queue<int> q;
		total.clear();
		push(s, n, 1, q);
		printf("%dn", total.size());
	}
	return 0;
}

输入输出

可以看到上面有重复，下面以 n 为 2 解释一下

n 为 2 的输出有 5 行，5 种过程如下

1. 1 压栈，不弹
2 压栈，不弹
所有数字压栈完毕，依次弹栈，并打印，输出是 2 1
1. 1 压栈，不弹
2 压栈，弹 1 一个数字，放入待打印队列，队列现为 2
所有数字压栈完毕，现在栈为 1，把 1 弹出来，追加到待打印队列，现在队列为 2 1，输出是 2 1
1. 1 压栈，不弹
2 压栈，弹 2 1 两个数字，放入待打印队列，队列现为 2 1
所有数字压栈完毕，现在栈为空，现在队列为 2 1，输出是 2 1
1. 1 压栈，并弹栈，放入待打印队列，队列现为 1
2 压栈，不弹
所有数字压栈完毕，现在栈为 2，把 2 弹出来，追加到待打印队列，现在队列为 1 2，输出是 1 2
1. 1 压栈，并弹，放入待打印队列，队列现为 1
2 压栈，并弹，放入待打印队列，队列现为 1 2
所有数字压栈完毕，现在栈为空，现在队列为 1 2，输出是 1 2

这个东西叫做卡特兰数，卡特兰数的性质可以参考这里，http://peng5047.iteye.com/blog/976822

1.卡特兰数是一种数列，以比利时的数学家欧仁·查理·卡塔兰命名。 2.卡特兰数列：1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012…… 令第n项为h(n)，则： h(0) = 1; h(1) = 1; h(n) = h(0)*h(n-1) + h(1)*h(n-2) + …… + h(n-1)*h(0)，其中n>=2 卡特兰数的另一种形式：h(n) = C(2n,n)/(n + 1)，其中n>=1

百度百科，http://baike.baidu.com/view/2499752.htm，里面也有关于这个的分析，写的挺清楚的，摘录过来

常规分析　　首先，我们设f（n）=序列个数为n的出栈序列种数。同时，我们假定第一个出栈的序数是k。　　第一个出栈的序数k将1~~n的序列分成两个序列，其中一个是1~~k-1，序列个数为k-1，另外一个是k+1~n，序列个数是n-k。　　此时，我们若把k视为确定一个序数，那么根据乘法原理，f（n）的问题就等价于——序列个数为k-1的出栈序列种数乘以序列个数为n - k的出栈序列种数，即选择k这个序数的f（n）=f（k-1）×f（n-k）。而k可以选1到n，所以再根据加法原理，将k取不同值的序列种数相加，得到的总序列种数为：f（n）=f（0）f（n-1）+f（1）f（n-2）+……+f（n-1）f（0）。　　看到此处，再看看卡特兰数的递推式，答案不言而喻，即为f（n）=h（n+1）= C（2n,n）/（n+1）= c（2n,n）-c（2n,n+1）（n=1，2，3，……）。　　最后，令f（0）=1，f（1）=1。　　非常规分析　　对于每一个数来说，必须进栈一次、出栈一次。我们把进栈设为状态‘1’，出栈设为状态‘0’。n个数的所有状态对应n个1和n个0组成的2n位二进制数。由于等待入栈的操作数按照1‥n的顺序排列、入栈的操作数b大于等于出栈的操作数a(a≤b)，因此输出序列的总数目=由左而右扫描由n个1和n个0组成的2n位二进制数，1的累计数不小于0的累计数的方案种数。　　在2n位二进制数中填入n个1的方案数为c(2n,n),不填1的其余n位自动填0。从中减去不符合要求（由左而右扫描，0的累计数大于1的累计数）的方案数即为所求。　　不符合要求的数的特征是由左而右扫描时，必然在某一奇数位2m+1位上首先出现m+1个0的累计数和m个1的累计数，此后的2(n-m)-1位上有n-m个 1和n-m-1个0。如若把后面这2(n-m)-1位上的0和1互换，使之成为n-m个0和n-m-1个1，结果得1个由n+1个0和n-1个1组成的2n位数，即一个不合要求的数对应于一个由n+1个0和n-1个1组成的排列。　　反过来，任何一个由n+1个0和n-1个1组成的2n位二进制数，由于0的个数多2个，2n为偶数，故必在某一个奇数位上出现0的累计数超过1的累计数。同样在后面部分0和1互换，使之成为由n个0和n个1组成的2n位数，即n+1个0和n-1个1组成的2n位数必对应一个不符合要求的数。　　因而不合要求的2n位数与n+1个0，n－1个1组成的排列一一对应。　　显然，不符合要求的方案数为c(2n,n+1)。由此得出输出序列的总数目=c(2n,n)-c(2n,n+1)=c(2n,n)/(n+1)=h(n+1)。

============================================

2012-10-14 23:25:11 update 这个题目在编程之美上也有讨论，在 274 页

蛇形填数

Sat, 22 Sep 2012 15:45:33 +0800

之前因为家里的原因，回乡下一个星期，期间都没有机会，也没有心情写代码，一个星期就这么毫无长进，罪过。

看到一个蛇形填数的题目，搞了搞，代码如下

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

void print(int **a, int n)
{
	for (int y=0; y<n; y++)
	{
		for (int x=0; x<n; x++)
		{
			printf("%dt", a[x][y]);
		}
		printf("n");
	}
	printf("n");
}

void clear(int **a, int n)
{
	for (int y=0; y<n; y++)
	{
		for (int x=0; x<n; x++)
		{
			a[x][y] = 0;
		}
	}
}

void fill(int **a, int n)
{
	int xx[4] = {1, 0, -1, 0};
	int yy[4] = {0, 1, 0, -1};
	int x=0, y=0, pos=0;
	for (int i=1; i<=n*n; i++)
	{
		a[x][y] = i;
		if (x+xx[pos]>=n || x+xx[pos]<0
			|| y+yy[pos]>=n || y+yy[pos]<0
			|| a[x+xx[pos]][y+yy[pos]]!=0)
		{
			pos = (pos+1) % 4;
		}
		x += xx[pos];
		y += yy[pos];
	}
}

int main()
{
	int n;
	while (scanf("%d", &n) != EOF)
	{

		int **a = (int **)malloc(sizeof(int *) * n);
		for (int i=0; i<n; i++)
		{
			a[i] = (int *)malloc(sizeof(int) * n);
		}
		clear(a, n);
		fill(a, n);
		print(a, n);
		for (int i=0; i<n; i++)
		{
			free(a[i]);
		}
		free(a);
	}
	return 0;
}

输入输出

2
1       2
4       3

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

生成可重集的排列

Fri, 14 Sep 2012 16:41:26 +0800

刘汝佳在算法竞赛入门经典，http://book.douban.com/subject/4138920/，的 118 页提到生成一个可重集的全排列问题，跟上次的生成一个字符串的全排列很相像，但是写法却巧妙很多

#include <stdio.h>

void quick_sort(int a[], int left, int right)
{
	int i=left, j=right;
	int povit = a[(i+j)/2];
	while (i <= j)
	{
		while (a[i] < povit)
		{
			i++;
		}
		while (a[j] > povit)
		{
			j--;
		}
		if (i <= j)
		{
			int tmp = a[j];
			a[j] = a[i];
			a[i] = tmp;
			i++;
			j--;
		}
	}
	if (left < j)
	{
		quick_sort(a, left, j);
	}
	if (i < right)
	{
		quick_sort(a, i, right);
	}
}

void print_permutation(int n, int *p, int *a, int cur)
{
	int i, j;
	if (cur == n)
	{
		for (i=0; i<n; i++)
		{
			printf("%d ", a[i]);
		}
		printf("n");
	}
	else
	{
		for (i=0; i<n; i++)
		{
			if (!i || p[i]!=p[i-1])
			{
				int c1=0, c2=0;
				for (j=0; j<cur; j++)
				{
					if (a[j] == p[i])
					{
						c1++;
					}
				}
				for (j=0; j<n; j++)
				{
					if (p[i] == p[j])
					{
						c2++;
					}
				}
				if (c1 < c2)
				{
					a[cur] = p[i];
					print_permutation(n, p, a, cur+1);
				}
			}
		}
	}
}

int main()
{
	int n;
	while (scanf("%d", &n) != EOF)
	{
		int *p = new int[n];
		for (int i=0; i<n; i++)
		{
			scanf("%d", &p[i]);
		}
		quick_sort(p, 0, n-1);
		int *a = new int[n];
		print_permutation(n, p, a, 0);
		delete[] p;
		delete[] a;
	}
	return 0;
}

输入输出

需要说明的是，他的这种全排列生成需要数组有序，于是顺便就当作复习了一遍快排了

简单枚举的除法

Fri, 14 Sep 2012 15:16:13 +0800

今天看到一个简单枚举的题目

除法输入正整数n，按从小到大的顺序输出所有形如abcde/fghij=n的表达式，其中a~~j恰好为数字0~~9的一个排列，2<=n<=79. 样例输入： 62 样例输出： 79546/01238=62 94736/01528=62

我是这么搞的

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

int n;

void enumerate(char dividend[], int div_index)
{
	if (div_index == 5)
	{
		int divide = atoi(dividend);
		int product = divide * n;
		if (product > 10000 && product <99999)
		{
			char product_str[6];
			sprintf(product_str, "%d", product);
			int map[10] = {0};
			int conflict = 0;
			for (int i=0; i<5; i++)
			{
				if (map[product_str[i]-'0'] == 0)
				{
					map[product_str[i]-'0']++;
				}
				else
				{
					conflict = 1;
					break;
				}
			}
			for (int i=0; i<5; i++)
			{
				if (map[dividend[i]-'0'] == 0)
				{
					map[dividend[i]-'0']++;
				}
				else
				{
					conflict = 1;
					break;
				}
			}
			if ( ! conflict)
			{
				printf("%s / %s = %dn", product_str, dividend, n);
			}
		}
		return;
	}
	for (char ch='0'; ch<='9'; ch++)
	{
		int occupy = 0;
		for (int i=0; i<div_index; i++)
		{
			if (dividend[i] == ch)
			{
				occupy = 1;
				break;
			}
		}
		if ( ! occupy)
		{
			dividend[div_index] = ch;
			enumerate(dividend, div_index+1);
		}
	}
}

int main()
{
	while (scanf("%d", &n) == 1)
	{
		char dividend[6] = {0};
		enumerate(dividend, 0);
	}
	return 0;
}

输入输出

62
79546 / 01283 = 62
94736 / 01528 = 62
7
16758 / 02394 = 7
18459 / 02637 = 7
31689 / 04527 = 7
36918 / 05274 = 7
37926 / 05418 = 7
41832 / 05976 = 7
53298 / 07614 = 7
98532 / 14076 = 7

不过这明显太长了，继续写短。。

参考这里，http://blog.csdn.net/xujinsmile/article/details/7592875，得到如下代码

#include <stdio.h>

int main()
{
	int n;
	while (scanf("%d", &n) != EOF)
	{
		for (int i=1234; i<=98765; i++)
		{
			if (n*i <= 98765)
			{
				int map[10] = {0};
				int ii=i, ni=n*i;
				for (int j=0; j<5; j++, ii/=10, ni/=10)
				{
					map[ii%10]++;
					map[ni%10]++;
				}
				for (int j=0; j<10; j++)
				{
					if (map[j] != 1)
					{
						break;
					}
					if (j == 9)
					{
						if (i < 10000)
						{
							printf("%d / 0%d = %dn", n*i, i, n);
						}
						else
						{
							printf("%d / %d = %dn", n*i, i, n);
						}
					}
				}
			}
		}
	}
	return 0;
}

输入输出

62
79546 / 01283 = 62
94736 / 01528 = 62
7
16758 / 02394 = 7
18459 / 02637 = 7
31689 / 04527 = 7
36918 / 05274 = 7
37926 / 05418 = 7
41832 / 05976 = 7
53298 / 07614 = 7
98532 / 14076 = 7

输出一个字符串的组合

Thu, 13 Sep 2012 18:36:10 +0800

跟上次输出一个字符串的排列类似，http://zrj.me/archives/472，要求输出一个字符串的组合，思路也是递归

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

void combine(char str[], int str_index, char res_total, char result[], int res_index)
{
	if (res_total == res_index)
	{
		for (int i=0; i<res_total; i++)
		{
			printf("%c ", result[i]);
		}
		printf("n");
	}
	else if (str_index==strlen(str))
	{
		return;
	}
	else
	{
		result[res_index] = str[str_index];
		combine(str, str_index+1, res_total, result, res_index+1);
		combine(str, str_index+1, res_total, result, res_index);
	}
}

int main()
{
	char str[100];
	char result[100];
	scanf("%s", str);
	for (int i = 1; i<=strlen(str); i++)
	{
		combine(str, 0, i, result, 0);
	}
	return 0;
}

输入输出

abcd
a
b
c
d
a b
a c
a d
b c
b d
c d
a b c
a b d
a c d
b c d
a b c d

可以发现没有考虑去重的情况，这个应该比较容易，就是预处理扫一遍，如果是 ascii 字符的话，那么把输入的 str 映射要一个位图上就可以了。

1亿以内的回文质数

Tue, 11 Sep 2012 19:57:25 +0800

今天下午看到这么一个题

找出 1 亿以内的回文质数

很自然的思路就是素数筛，然后验证回文性质

#include <iostream>
#include <cmath>
#include <ctime>

#define TOTAL 100000000

using namespace std;

bool is_prime[TOTAL];

void Sieve_of_Eratosthenes()
{
	memset(is_prime, 1, sizeof(is_prime));
	is_prime[0] = is_prime[1] = false;
	for (int i=2; i<sqrt(TOTAL+0.5); i++)
	{
		if (is_prime[i])
		{
			for (int j=i*i; j<TOTAL; j+=i)
			{
				is_prime[j] = false;
			}
		}
	}
}

void test_palin()
{
	for (int i=2; i<TOTAL; i++)
	{
		if (is_prime[i])
		{
			int cpy = i, sum;
			for (sum=0; cpy!=0; cpy/=10)
			{
				sum = sum*10 + cpy%10;
			}
			if (sum == i)
			{
				printf("%dn", i);
			}
		}
	}
}

int main()
{
	Sieve_of_Eratosthenes();
	test_palin();
	printf("%lfn", (double)clock()/CLOCKS_PER_SEC);
	return 0;
}

上面这个素数筛在我的电脑上跑需要 4.07 秒，加上验证函数，耗时在 5.0 秒左右波动

思路是没错，但是略慢了，可以看到主要时间耗在打表上，上网翻看了一下，http://wenku.baidu.com/view/8ee7ce7301f69e31433294e7.html，别人的思路不是打表，而是先判断回文，再判断质数，而是质数判断就直接穷举去除，看到他的最好的方法方法四是 0.5 秒，于是照着这个思路，重新搞，简单分析可以知道，任何一个 k 位正整数都可以产生一个 2*k 位和一个 2*k-1 位两个回文整数，例如，12 可以产生 121 和 1221 这两个，然后我们又知道，1 亿以内最大的数就是 99999999 了，8 个 9，那产生的时候最大也就 4 位数就可以了，照着这个思路，得到如下代码

#include <stdio.h>
#include <math.h>
#include <time.h>

int is_prime(int x)
{
	for (int i=2; i<sqrt(x+0.5); i++)
	{
		if (x%i == 0)
		{
			return 0;
		}
	}
	return 1;
}

void gener_palin()
{
	for (int i=1; i<10000; i++)
	{
		// 根据 k 位数 i 产生 2*k 位的回文数
		int cpy = i, sum;
		for (sum=i; cpy!=0; cpy/=10)
		{
			sum = sum*10 + cpy%10;
		}
		if (is_prime(sum))
		{
			printf("%dn", sum);
		}

		// 产生 2*k-1 位的回文数
		cpy = i/10;
		for (sum=i; cpy!=0; cpy/=10)
		{
			sum = sum*10 + cpy%10;
		}
		if (is_prime(sum))
		{
			printf("%dn", sum);
		}
	}
}

int main()
{
	gener_palin();
	printf("%lfn", (double)clock()/CLOCKS_PER_SEC);
	return 0;
}

这个代码在我的机子上可以跑到 0.25 秒，如图

根据经验，卷屏输出是耗时大户，把 29 和 40 行注释掉，可以跑到 0.03 秒

Faulty Odometer

Sun, 09 Sep 2012 14:09:51 +0800

今天上午看了一下榜，http://acmicpc.info/icpc2012/tjut_online.php，发现大家 a 题刷刷的过，于是自己也敲了一下，好久没有敲题，居然一次过了 sample，呵呵，不过后来跟同学讨论的时候，发现我那个暴力模拟的思路实在太弱智了，在同学的指点下改成了进制转换的思路，没有账号，所以没有的交，不过 sample 是过了

题目，附上 pdf，2012TianJinOnlineProblemSet

Description You are given a car odometer which displays the miles traveled as an integer. The odometer has a defect, however: it proceeds from the digit 2 to the digit 4 and from the digit 7 to the digit 9, always skipping over the digit 3 and 8. This defect shows up in all positions (the one’s, the ten’s, the hundred’s, etc.). For example, if the odometer displays 15229 and the car travels one mile, odometer reading changes to 15240 (instead of 15230). Input Each line of input contains a positive integer in the range 1..999999999 which represents an odometer reading. (Leading zeros will not appear in the input.) The end of input is indicated by a line containing a single 0. You may assume that no odometer reading will contain the digit 3 and 8. Output Each line of input will produce exactly one line of output, which will contain: the odometer reading from the input, a colon, one blank space, and the actual number of miles traveled by the car.

Sample Input 15 2005 250 1500 999999 0

Sample Output 15: 12 2005: 1028 250: 160 1500: 768 999999: 262143

代码

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

int main() {
	int x;
	while (scanf("%d", &x) && x!=0) {
		char str[15] = {0};
		itoa(x, str, 10);
		for (int i=0; i<strlen(str); i++) {
			if (str[i] >= '8') {
				str[i] -= 2;
				continue;
			}
			if (str[i] >= '3') {
				str[i] -= 1;
				continue;
			}
		}
		int ans = 0;
		for (char *p=str; *p != '\0'; p++) {
			ans = ans*8 + (*p-'0');
		}
		printf("%d: %dn", x, ans);
	}
	return 0;
}

输入输出

15
15: 12
2005
2005: 1028
250
250: 160
1500
1500: 768
999999
999999: 262143
0

===================================

2012-9-9 21:30:09 update oj 上开放了题目，http://acm.hdu.edu.cn/showproblem.php?pid=4278，于是交了一下，不能用 itoa，于是改成了这样，能够 ac

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

int main() {
	int x;
	while (scanf("%d", &x) && x!=0) {
		char str[15] = {0};
		sprintf(str, "%d", x);
		for (int i=0; i<strlen(str); i++) {
			if (str[i] >= '8') {
				str[i] -= 2;
				continue;
			}
			if (str[i] >= '3') {
				str[i] -= 1;
				continue;
			}
		}
		int ans = 0;
		for (char *p=str; *p != '\0'; p++) {
			ans = ans*8 + (*p-'0');
		}
		printf("%d: %dn", x, ans);
	}
	return 0;
}

链表的反转

Sat, 08 Sep 2012 12:19:13 +0800

今天上午自己写了一个链表的反转

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

typedef struct _node
{
	int n;
	_node *next;
} node;

int create_link(node **phead)
{
	int x = 0;
	printf("input nums, press Ctrl+Z(win) or Ctrl+D(linux) to endn");
	if (scanf("%d", &x) <= 0)
	{
		return 0;
	}
	*phead = (node *)malloc(sizeof(node));
	if ( ! *phead)
	{
		return 1;
	}
	(*phead)->n = x;
	(*phead)->next = NULL;
	node *now = *phead;
	while (scanf("%d", &x) == 1)
	{
		node *new_node = (node *)malloc(sizeof(node));
		if ( ! new_node)
		{
			// TO-DO: free memory
			return 1;
		}
		new_node->n = x;
		new_node->next = NULL;
		now->next = new_node;
		now = new_node;
	}
	return 0;
}

void print_link(node *head)
{
	node *now = head;
	while (now)
	{
		printf("%d", now->n);
		if (now->next)
		{
			printf(" -> ");
		}
		now = now->next;
	}
	printf("n");
}

void delete_link(node **head)
{
	node *now = *head;
	while (now)
	{
		node *tmp = now->next;
		free(now);
		now = tmp;
	}
	*head = NULL;
}

void reverse_link(node **phead)
{
	node *pre = *phead;
	node *curr = pre->next;
	if ( ! curr)
	{
		// 只有一个节点
		return;
	}
	node *next = curr->next;
	pre->next = NULL;
	while (1)
	{
		curr->next = pre;
		if (next)
		{
			pre = curr;
			curr = next;
			next = next->next;
		}
		else
		{
			break;
		}
	}
	*phead = curr;
}

int main()
{
	node *head = NULL;
	create_link(&head);
	print_link(head);
	reverse_link(&head);
	print_link(head);
	delete_link(&head);
	return 0;
}

输入输出

input nums, press Ctrl+Z(win) or Ctrl+D(linux) to end
3 1 2 4 0
^Z
3 -> 1 -> 2 -> 4 -> 0
0 -> 4 -> 2 -> 1 -> 3

==================================================

2012-09-08 12:39:03 update 参考这里 http://blog.csdn.net/rerli/article/details/19038，反转函数有更简单的写法

void reverse_link(node **phead)
{
	node *pre = NULL;
	node *curr = *phead;
	node *next = NULL;
	while (curr)
	{
		next = curr->next;
		curr->next = pre;
		pre = curr;
		curr = next;
	}
	*phead = pre;
}

================================================

参考这里，http://blog.csdn.net/rerli/article/details/19039，写了链表的插入排序

void insert_sort(node **phead)
{
	node *head = *phead;
	// 把 head 的下一节点保存起来
	node *first = head->next;
	// 断开 head，使其成为初始的有序链表
	head->next = NULL;
	while (first)
	{
		node *p, *q, *t;
		// 找到插入点
		for (t=first, q=head; q && q->n < t->n; p=q, q=q->next);
		// 把 first 节点从无序链表中断开
		first = first->next;

		if (q == head)
		{
			// 插入在头结点之前
			head = t;
		}
		else
		{
			// p 是 q 的前驱
			p->next = t;
		}
		t->next = q;
	}
	*phead = head;
}

======================================================

2012-09-08 15:02:07 update 相比于传二维指针，可以使用 c++ 的写法，传引用，这样可读性会高很多

int create_link(node *&head)
{
	int x = 0;
	printf("input nums, press Ctrl+Z(win) or Ctrl+D(linux) to endn");
	if (scanf("%d", &x) <= 0)
	{
		return 0;
	}
	head = (node *)malloc(sizeof(node));
	if ( ! head)
	{
		return 1;
	}
	head->n = x;
	head->next = NULL;
	node *now = head;
	while (scanf("%d", &x) == 1)
	{
		node *new_node = (node *)malloc(sizeof(node));
		if ( ! new_node)
		{
			// TO-DO: free memory
			return 1;
		}
		new_node->n = x;
		new_node->next = NULL;
		now->next = new_node;
		now = new_node;
	}
	return 0;
}

调用的时候改成

int main()
{
	node *head = NULL;
	create_link(head);
	print_link(head);
	reverse_link(&head);
	print_link(head);
	insert_sort(&head);
	print_link(head);
	delete_link(&head);
	return 0;
}

输出一个字符串的全排列

Thu, 06 Sep 2012 20:44:02 +0800

今天看到 http://blog.csdn.net/morewindows/article/details/7370155 这里提出了一个问题

用C++写一个函数, 如 Foo(const char *str), 打印出 str 的全排列, 如 abc 的全排列: abc, acb, bca, dac, cab, cba

想了想（想了好久啊，好久没有碰数据结构和算法了），觉得可以 dfs，这样来搞：

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

#define MAX 1000

char str[MAX];
int len;
char tmp[MAX];
char used[MAX];

void arrange(int pos)
{
	if (pos >= len)
	{
		printf("%sn", tmp);
		return;
	}
	int i = 0;
	for (i=0; i<len; i++)
	{
		if ( ! used[i])
		{
			used[i] = 1;
			tmp[pos] = str[i];
			arrange(pos+1);
			used[i] = 0;
		}
	}
}

int main()
{
	scanf("%s", str);
	len = strlen(str);
	memset(used, 0, sizeof(used));
	memset(tmp, 0, sizeof(tmp));
	arrange(0);
	return 0;
}

结果如下：

但是问题是如果过滤掉重复的呢，最简单的一个想法是，用 stl 搞个 set，找到的结果先不打印出来，统统往 set 里面装，让 set 天然的帮我们过滤，最后用一个循环输出出来，但是，如果自己实现呢，回头看我们之前的代码，我们可以发现，在 dfs 的时候，字符在串中位置是有影响的，也就是说，对于上面的程序来说，abca 和 abac 是不一样的，但是，我们却希望，字符在串中的位置是无关紧要的，自然就想到，如果我们把相同的字符归成一群，这样就能解决问题，也就是说，我们需要把刚刚那两个串预处理一下，把他们都变成，一坨 a，然后一个 b，然后一个 c，于是得到下面的代码

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

#define MAX 1000

typedef struct _letter {
	char ch;
	int count;
} letter;

letter letters[MAX];
int letters_arr_size = 0;

char input[MAX];
int len;
char tmp[MAX];

void preprocess();
void dfs(int pos);

int main()
{
	scanf("%s", input);
	len = strlen(input);
	preprocess();
	dfs(0);
	return 0;
}

void preprocess()
{
	memset(letters, 0, sizeof(letters));
	int i, j, found=0;
	for (i=0; i<len; i++)
	{
		found = 0;
		for (j=0; j<letters_arr_size; j++)
		{
			if (input[i] == letters[j].ch)
			{
				letters[j].count++;
				found = 1;
				break;
			}
		}
		if ( ! found)
		{
			letters[letters_arr_size].ch = input[i];
			letters[letters_arr_size].count = 1;
			letters_arr_size++;
		}
	}
}

void dfs(int pos)
{
	if (pos >= len)
	{
		printf("%sn", tmp);
		return;
	}
	int i;
	for (i=0; i<letters_arr_size; i++)
	{
		if (letters[i].count > 0)
		{
			letters[i].count--;
			tmp[pos] = letters[i].ch;
			dfs(pos+1);
			letters[i].count++;
		}
	}
}

结果如下

但是至于怎么把这段递归等价的改写成循环，想了很是有一会儿，可惜暂时没有想出来

历史评论

输出一个字符串的组合 | ZRJ (2012-09-13 18:36:14):

[…] 跟上次输出一个字符串的排列类似，http://zrj.me/archives/472，要求输出一个字符串的组合，思路也是递归 […]

生成可重集的排列 | ZRJ (2012-09-14 16:41:32):

[…] 118 页提到生成一个可重集的全排列问题，跟上次的生成一个字符串的全排列 […]

Linux C 多线程初步

Tue, 04 Sep 2012 22:07:23 +0800

晚上想起来要敲一个 C 的多线程，于是搜了一下，找到这篇，http://zhuwenlong.blog.51cto.com/blog/209020/40339

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <sys/time.h>

#define MAX 10

pthread_t thread[2];
pthread_mutex_t mut;

int number=0, i;

void *thread1() {
    printf("thread1n");
    for (i=0; i<MAX; i++) {
        printf("thread1, number = %dn", number);
        pthread_mutex_lock(&mut);
        number++;
        pthread_mutex_unlock(&mut);
        sleep(2);
    }
    printf("thread1, is main processing waiting for me?n");
    pthread_exit(NULL);
}

void *thread2() {
    printf("thread2n");
    for (i=0; i<MAX; i++) {
        printf("thread2, number = %dn", number);
        pthread_mutex_lock(&mut);
        number++;
        pthread_mutex_unlock(&mut);
        sleep(3);
    }
    printf("thread2, is main processing waiting for me?n");
    pthread_exit(NULL);
}

void thread_create() {
    int temp;
    memset(&thread, 0, sizeof(thread));
    if ((temp = pthread_create(&thread[0], NULL, thread1, NULL)) != 0) {
        printf("create threadh 1 failedn");
    } else {
        printf("successfully create thread 1n");
    }

    if ((temp = pthread_create(&thread[1], NULL, thread2, NULL)) != 0) {
        printf("create threadh 2 failedn");
    } else {
        printf("successfully create thread 2n");
    }
}

void thread_wait() {
    if (thread[0] != 0) {
        pthread_join(thread[0], NULL);
        printf("thread 1 endn");
    }
    if (thread[1] != 0) {
        pthread_join(thread[1], NULL);
        printf("thread 2 endn");
    }
}

int main() {
    printf("hello worldn");
    pthread_mutex_init(&mut, NULL);
    printf("this is the main processn");
    thread_create();
    printf("main process is waiting for pthread to finishn");
    thread_wait();
    return 0;
}

需要注意的是，编译的时候需要手工链接进程库

gcc -pthread thread.c

后续的解释，直接引用了。。

引文:

线程相关操作

一 pthread_t

pthread_t在头文件/usr/include/bits/pthreadtypes.h中定义：

typedef unsigned long int pthread_t;

它是一个线程的标识符。

二 pthread_create

函数pthread_create用来创建一个线程，它的原型为：

extern int pthread_create __P ((pthread_t *__thread, __const pthread_attr_t *__attr,

void *(*__start_routine) (void *), void *__arg));

第一个参数为指向线程标识符的指针，第二个参数用来设置线程属性，第三个参数是线程运行函数的起始地址，最后一个参数是运行函数的参数。这里，我们的函数thread不需要参数，所以最后一个参数设为空指针。第二个参数我们也设为空指针，这样将生成默认属性的线程。对线程属性的设定和修改我们将在下一节阐述。当创建线程成功时，函数返回0，若不为0则说明创建线程失败，常见的错误返回代码为EAGAIN和EINVAL。前者表示系统限制创建新的线程，例如线程数目过多了；后者表示第二个参数代表的线程属性值非法。创建线程成功后，新创建的线程则运行参数三和参数四确定的函数，原来的线程则继续运行下一行代码。

三 pthread_join pthread_exit

函数pthread_join用来等待一个线程的结束。函数原型为：

extern int pthread_join __P ((pthread_t __th, void **__thread_return));

第一个参数为被等待的线程标识符，第二个参数为一个用户定义的指针，它可以用来存储被等待线程的返回值。这个函数是一个线程阻塞的函数，调用它的函数将一直等待到被等待的线程结束为止，当函数返回时，被等待线程的资源被收回。一个线程的结束有两种途径，一种是象我们上面的例子一样，函数结束了，调用它的线程也就结束了；另一种方式是通过函数pthread_exit来实现。它的函数原型为：

extern void pthread_exit __P ((void *__retval)) __attribute__ ((__noreturn__));

唯一的参数是函数的返回代码，只要pthread_join中的第二个参数thread_return不是NULL，这个值将被传递给 thread_return。最后要说明的是，一个线程不能被多个线程等待，否则第一个接收到信号的线程成功返回，其余调用pthread_join的线程则返回错误代码ESRCH。

在这一节里，我们编写了一个最简单的线程，并掌握了最常用的三个函数pthread_create，pthread_join和pthread_exit。下面，我们来了解线程的一些常用属性以及如何设置这些属性。

互斥锁相关

互斥锁用来保证一段时间内只有一个线程在执行一段代码。

一 pthread_mutex_init

函数pthread_mutex_init用来生成一个互斥锁。NULL参数表明使用默认属性。如果需要声明特定属性的互斥锁，须调用函数 pthread_mutexattr_init。函数pthread_mutexattr_setpshared和函数 pthread_mutexattr_settype用来设置互斥锁属性。前一个函数设置属性pshared，它有两个取值， PTHREAD_PROCESS_PRIVATE和PTHREAD_PROCESS_SHARED。前者用来不同进程中的线程同步，后者用于同步本进程的不同线程。在上面的例子中，我们使用的是默认属性PTHREAD_PROCESS_ PRIVATE。后者用来设置互斥锁类型，可选的类型有PTHREAD_MUTEX_NORMAL、PTHREAD_MUTEX_ERRORCHECK、 PTHREAD_MUTEX_RECURSIVE和PTHREAD _MUTEX_DEFAULT。它们分别定义了不同的上所、解锁机制，一般情况下，选用最后一个默认属性。

二 pthread_mutex_lock pthread_mutex_unlock pthread_delay_np

pthread_mutex_lock声明开始用互斥锁上锁，此后的代码直至调用pthread_mutex_unlock为止，均被上锁，即同一时间只能被一个线程调用执行。当一个线程执行到pthread_mutex_lock处时，如果该锁此时被另一个线程使用，那此线程被阻塞，即程序将等待到另一个线程释放此互斥锁。

注意：

1 需要说明的是，上面的两处sleep不光是为了演示的需要，也是为了让线程睡眠一段时间，让线程释放互斥锁，等待另一个线程使用此锁。下面的参考资料1里头说明了该问题。但是在linux下好像没有pthread_delay_np那个函数（我试了一下，提示没有定义该函数的引用），所以我用了sleep来代替，不过参考资料2中给出另一种方法，好像是通过pthread_cond_timedwait来代替，里头给出了一种实现的办法。

2 请千万要注意里头的注释comment1-5，那是我花了几个小时才找出的问题所在。

如果没有comment1和comment4,comment5,将导致在pthread_join的时候出现段错误，另外，上面的comment2和comment3是根源所在，所以千万要记得写全代码。因为上面的线程可能没有创建成功，导致下面不可能等到那个线程结束，而在用pthread_join的时候出现段错误（访问了未知的内存区）。另外，在使用memset的时候，需要包含string.h头文件哦

==================================================

刚刚需要用的时候，发现上面的代码不能跑，神奇，我当时是怎么出结果的，下面的代码可以跑

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <stdlib.h>
#include <sys/time.h>
#include <unistd.h>

#define MAX 10

pthread_t thread[2];
pthread_mutex_t mut;

int number=0, i;

void *thread1(void *) {
    printf("thread1\n");
    for (i=0; i<MAX; i++) {
        printf("thread1, number = %d\n", number);
        pthread_mutex_lock(&mut);
        number++;
        pthread_mutex_unlock(&mut);
        sleep(2);
    }
    printf("thread1, is main processing waiting for me?\n");
    pthread_exit(NULL);
}

void *thread2(void *) {
    printf("thread2\n");
    for (i=0; i<MAX; i++) {
        printf("thread2, number = %d\n", number);
        pthread_mutex_lock(&mut);
        number++;
        pthread_mutex_unlock(&mut);
        sleep(3);
    }
    printf("thread2, is main processing waiting for me?\n");
    pthread_exit(NULL);
}

void thread_create() {
    int temp;
    memset(&thread, 0, sizeof(thread));
    if ((temp = pthread_create(&thread[0], NULL, thread1, NULL)) != 0) {
        printf("create threadh 1 failed\n");
    } else {
        printf("successfully create thread 1\n");
    }

    if ((temp = pthread_create(&thread[1], NULL, thread2, NULL)) != 0) {
        printf("create threadh 2 failed\n");
    } else {
        printf("successfully create thread 2\n");
    }
}

void thread_wait() {
    if (thread[0] != 0) {
        pthread_join(thread[0], NULL);
        printf("thread 1 end\n");
    }
    if (thread[1] != 0) {
        pthread_join(thread[1], NULL);
        printf("thread 2 end\n");
    }
}

int main() {
    printf("hello world\n");
    pthread_mutex_init(&mut, NULL);
    printf("this is the main process\n");
    thread_create();
    printf("main process is waiting for pthread to finish\n");
    thread_wait();
    return 0;
}