这几天在做一个API的时候，由于后端服务器量太多，导致前段webserver的CGI连接数过多，所以，不得不使用连接池来进行管理。（好吧，我知道说出来有点恐怖，600台webserver，125台32G的cache服务器，也就是cache量接近3T……）
之前有人实现过，大体思路如下：
1）定义一个list数组，里面的每个指针对象维护一条连接，并且为list规定一个最大值。
2）每当有信莲连接生成时（或者已经有的连接重新使用），就向list中添加一个对象；如果list的大小已经大于最大值，那么就把最后一个对象关闭并且扔出连接池（也就是要求，在这个对象的连接被断掉后，这个对象再次使用时，应该有重连的功能）

这样做的确比较简单，但是也会产生如下几个问题：
1）在第二点中，如果是已经有的连接重新使用，假设我们规定list的最大大小为1，那么这个被重复使用的连接实际上是在被重复的关闭和重新打开。
2）没有权重的概念，即可能对于一个访问频率比较高的连接，很可能会被一个访问量比较低的连接冲击导致连接断掉。

基于以上考虑，我重新设计了一套连接池模型：

typedef _conn_info
{
    int iCreateTime;//就是创建这个结构体的时间（第一次建立连接时的时间）
    int iLastTime;//最后一次被调用的时间
    int iReq;//被使用到的次数
    CConnClass* ptrConn;//对象的指针，维护着一个长连接 ...

众所周知，大名鼎鼎的STL使用大量的模板，但是有时候我们也会面临一些需求，比如map或者vector里的数据类型被定义成模板，但这个时候，用起来就会出现问题。
我们先来看一个没有问题的例子：

/*===========================================================
#  Author:          DanteZhu - https://www.vimer.cn
#  Email:           dantezhu@vip.qq.com
#  FileName:        tem.cpp
#  Version:         1.0
#  LastChange:      2010-01-12 10:20:07
#  Description:     
#  History:         
===========================================================*/
#include <iostream>
#include <string>
#include <vector>
#include <map>
using namespace std;
typedef struct _CTT
{
    int len ;
}CTT;
template <typename T>
class CParse
{
    public:
        static ...

这几天在写一个项目，其中有用到打包和解包的网络通信，相信有过网络编程经验的朋友应该都知道，无非就是 将一个结构体打包成一段buff，以及反向的过程。（这里我们不考虑直接memcpy的情况，因为结构体里的字段有可能只是指针，当然如果都是定长数据的话，那么memcpy当然是最快的） 而在这个过程中，很多代码只是改了很少一部分，但是却要分别写两个函数，严重浪费了人力，而且容易出错。现在让我们看一下，能否用vim来替我们自动完成这件枯燥的事情。 我们来看这样一段示例代码：

int Output( unsigned int ver, char* & buf, int & iLen, int iMaxLen )
{
    int needLen = sizeof(char) * 3 + sizeof(short) + sizeof(int);
    if( needLen > iMaxLen )
    {         
        return FBErrSystemNoMem;
    }     
    char *t_Buff = buff;
    *(unsigned char *) t_Buff = placeId;
    t_Buff += sizeof ...

在C/C++中，我们经常会需要实现类似printf这样的函数，即函数的参数个数是不定的，这个时候就需要用到我们这篇文章讲到的方法啦。
首先，我们要知道这种函数，如何来定义。比如我想实现一个函数能够支持 fun(“%d”,1);
那么这个函数的定义实际上如下：

void fun(const char *fmt, …);

其中…的意思是说参数无法一一列出，所以用…代替，至于怎么解，我们稍后再说。
比较特殊的一点是，如果你希望将上面的函数定义成一个宏，那么这个宏可以这样写：

#define FUN(fmt, args…)    fun(fmt, ##args)

又假设你希望宏能够自动加上换行符，那么可以这样写：

#define FUN(fmt, args…)    fun(fmt“\n”, ##args)

OK，那么函数定义的问题我们就解决啦，但是怎么来解呢？
C里面提供了va_start,va_arg,va_end这样几个函数，解释如下：
va_start使argp指向第一个可选参数。va_arg返回参数列表中的当前参数并使argp指向参数列表中的下一个参数。va_end把argp指针清为NULL。函数体内可以多次遍历这些参数 ...

之前已经在博客里写过一篇关于限速的文章，这几天给别人用时发现，用C方式的结构式代码的确不方便别人使用，所以就用C++封装了一下，用起来也简单了很多。
主要实现了：
1.对速度的限制
2.动态调整速度的侦测周期，减少由于限速而带来的对CPU的消耗。
希望大家批评建议。

使用方法很简单，如下：

#include <iostream>
#include "timelimit.h"
using namespace std;
int main()
{
    CTimeLimit timelimit;
    //设置每秒最多10个
    timelimit.Init(10);
    while(1)
    {
        timelimit.DetectAndLimit();
        printf("%d\n",timelimit.Speed());
    }
}

源代码下载

在服务器上，我们经常会有多个CPU的情况，而此时如果把进程都绑定在一个CPU上，那么对资源太多浪费了，下面的代码就实现了如何将程序绑定在不同的cpu上。传入参数代表绑定第几个cpu（从0开始计算）

//cpu_test.cpp
#include<stdlib.h>
#include<stdio.h>
#include<sys/types.h>
#include<sys/sysinfo.h>
#include<unistd.h>
//#define __USE_GNU
#include<sched.h>
#include<ctype.h>
#include<string.h>
int main(int argc, char* argv[])
{
        int num = sysconf(_SC_NPROCESSORS_CONF);
        int created_thread = 0;
        int myid;
        int i;
        int j = 0;
        cpu_set_t mask;
        cpu_set_t get;
        if (argc ...

前几天在工作中需要写一段代码，获取一些文件的大小，心想：这还不简单吗？直接用标准C 的文件操作函数就OK了。于是写了下面的一段代码来实现：

unsigned long get_file_size(const char *filename)
{
    unsigned long size;
    FILE* fp = fopen( filename, "rb" );
    if(fp==NULL)
    {
        printf("ERROR: Open file %s failed.\n", filename);
        return 0;
    }
    fseek( fp, SEEK_SET, SEEK_END );
    size=ftell(fp);
    fclose(fp);
    return size;
}

没有想到的是，在程序执行后发现有的文件能正确的获取大小，而有的文件则不能正确的获取到文件大小，检查了代码，也没有发现有什么不对的地方。但是在这过程中发现了一个问题，就是能正确获取大小的文件都是相对比较小的文件，而出现错误的都是很大的文件。于是想到会不会是因为标准C文件操作函数对超过一定大小的文件不支持所造成的呢，于是Google了一下 ...

这几天在写一个server，由于框架相同，仅仅是获取数据源的地方有区别，所以，研究了一下如何使用面向对象的方法来动态加载so。

主要思想就是：
1.通过一个函数能够获得一个基类的指针，这样在调用基类的函数的时候，就能自动调用子类的实现了。
2.存储so对象的指针应该是外层类的一个static变量。

详细还是看代码吧：
1）首先定义一个公共的头文件，里面存储的基类的定义：（需要注意的就是，只要不是纯虚函数，那么就一定要有实现；还有就是析构函数需要为虚函数）
so和主调程序都需要包含这个头文件。
source_base.h

#ifndef _SOURCE_BASE_H_
#define _SOURCE_BASE_H_
#include <iostream>
using namespace std;
class CSourceBase;
/** 
 * @brief    获取实例
 * 
 * @param    client        new出的指针
 * 
 * @return    0            succ
 *             else        fail
 */
extern “C” int CreatObj(CSourceBase *& client);
class CSourceBase
{
    public:
        CSourceBase ...

如何保证一个程序在单台服务器上只有唯一实例呢，本着简单实用的思想写了一个实现函数：

/* 判断当前进程是否已经运行 */
static bool is_running(const char* prg)
{
    const char* pid_file = ".tmp_pid";
    const char* p = strrchr(prg, '/');
    if (p)
    {
        p++;
    }
    else
    {
        p = prg;
    }
    char cmd[128] = {0};
    sprintf(cmd, "pgrep %s >%s", p, pid_file);
    system(cmd);
    std::string s;
    FILE* fp = fopen(pid_file, "r");
    if (fp == NULL)
    {
        fprintf(stderr, "ERROR: can not open ...

最近项目小组在去除代码中的warning，在修正代码的过程中看到了对结构体不正确的初始化方式：
假设有一个如下的struct定义：

struct astruct
{
    int a;
    int b;
};
struct astruct test = {0};

即使astruct中都是基础类型的成员这样的初始化话也是不正确的。
这种初始化仅仅是把a变量设置为了0，而未对b变量做初始化。
产生这样错误的原因，大概是收到数组初始化的影响。数组是可以这么初始化话的，而且初始化的值只能是0！
对结构体的初始化，可以有一下三种。

struct test
{
    int a;
    int b;
};
int main()
{
    struct test t1 = {0, 0}; 
    struct test t2 = { 
        .a=2, 
        .b=3
    };  
    struct test t3 = { 
        a:12345,
        b:567890
    };  
    printf("t1.a = %d, t1.b ...