#define中##用法

基本用法

  #define to_string( s )  #s 

  cout < < to_string( Hello World! ) < < endl; 

理解为 cout < < "Hello World!" < < endl; 

使用##连结##前后的内容.

    #define concatenate( x, y )  x##y 

    int xy = 10; 

    cout < < concatenate( x, y ) < < endl; 

解释为 cout < < xy < < endl; 

理所当然,将会在标准输出处显示'10'.

#define f(a,b) a##b 

#define d(a) #a －－》 以"#"开头的，直接替换，不展开：immediately replaced by the unexpanded actual argument 

#define s(a) d(a) －－》 非以"#"开头的，先展开，再替换，也就是一般的情况 

void main( void ) 

{ 

    puts(d(f(a,b))); 

    puts(s(f(a,b))); 

} 

输出结果: 

f(a,b) 

ab

所以就两种情况： 

1，不以"#"开头的，先展开参数a，然后是替换代码：puts(s(f(a,b)));-->puts(s(ab))-->puts(d(ab))-->puts("ab") 
2，以"#"开头的，直接替换，不展开：puts(d(f(a,b)))-->puts("f(a,b)")

总结：先看外层 如果第一个宏是#开头则直接展开即可 否则从内向外展开 

看个Traffic Server中Continuation协程类的定义

#include <iostream>

class Continuation;

template <class C>
class SLink
{
public:
C *next;
SLink() : next(NULL){};
};

template <class C>
struct Link : public SLink<C>
{
C *prev;
Link() : prev(NULL) {}
};

#define LINK(_c, _f)                  \
class Link##_##_f : public Link<_c> \
{                                   \
public:                             \
static _c *&                      \
next_link(_c *c)                  \
{                                 \
return c->_f.next;              \
}                                 \
static _c *&                      \
prev_link(_c *c)                  \
{                                 \
return c->_f.prev;              \
}                                 \
static const _c *                 \
next_link(const _c *c)            \
{                                 \
return c->_f.next;              \
}                                 \
static const _c *                 \
prev_link(const _c *c)            \
{                                 \
return c->_f.prev;              \
}                                 \
};                                  \
Link<_c> _f

class Continuation
{
public:
LINK(Continuation, link);
void print() {std::cout<<"fun\n";}
};

int main()
{
Continuation c1;
Continuation c2;

c1.link.next = &c2;
c2.link.prev = &c1;

return 0;
}

其实很简单 只要不粗心 真的用脑思考就会发现 协程类中有个link成员 

而link中包含了 前驱节点指针和后续节点指针 即协程类是个双向的链表

通过link成员 将各节点串联起来

通过Link_link成员 返回出前驱、后续节点

参考链接 http://blog.csdn.net/qq_15457239/article/details/56842450