Category: 不学无术

附件：Yacc与Lex快速入门
http://orz.dayandcarrot.net/wordpress/wp-content/uploads/2013/05/Yacc与Lex快速入门.pdf
 
Lex 和 Yacc 是 UNIX 两个非常重要的、功能强大的工具。事实上，如果你熟练掌握
Lex 和 Yacc 的话，它们的强大功能使创建 FORTRAN 和 C 的编译器如同儿戏。
Ashish Bansal 为您详细的讨论了编写自己的语言和编译器所用到的这两种工具，包
括常规表达式、声明、匹配模式、变量、Yacc 语法和解析器代码。最后，他解释了
怎样把 Lex 和 Yacc 结合起来。
详见附件

• 本文来源及参考资料：

1. http://hi.baidu.com/beanchx/item/b153390de0691827a1312d49
2. http://www.2cto.com/kf/201302/191521.html
3. http://dev.21tx.com/2009/09/26/11354.html

　1. 子集构造(Subset Construction)

这是一个转换NFA到DFA的算法。我们知道NFA和DFA的区别最主要的就是一个状态和一个input symbol是否能够确定一个状态的问题，对于NFA，它将确定一个组状态，而DFA将确定一个状态，因此，我们有一个很好的办法就是把NFA的状态集对应每个DFA的状态，这就是subset construction的思想，不过这只是大概泛泛而论，我们需要更加明确的认识
1) NFA在任何一个input symbol下，映射的状态集(通过move函数，这个集合通常用T字母表示)应该被知道
2) 必须保证1)中状态集都对应了DFA中的一个状态

　　具体算法：

Input : 一个NFA N
Output : 接受相同语言的DFA D
Method : 为D构架一个transition table(转换表) Dtran，每个DFA的状态是一个NFA的状态集合(这里一定要注意前面说过的1)2)两点)。我们定义一些操作：
s 表示NFA的状态，T 表示NFA的状态集合，a表示一个input symbol
ε-transition(ε转换)就是说input symbol为ε时的transition(转换)
 

 
注意一下，所有的操作都是针对NFA的状态或者状态集合，得到的时NFA的状态集合，或者说是DFA看为一个状态
Subset Construction
初始Dstates，它仅仅含有状态(D的状态)ε-closure(s0)，并且状态未被标记，s0表示开始状态，注意，Dstates放的是D的状态
while　(　Dstates　有未标记的状态　T　)　{　//　T是D中的一个状态，也是N中一个状态集
标记　T;
for　(　input　symbol　a　){　　　　　　　　　　　　　　　　　　//　遍历所有的input　symbol
U　=　ε-closure(move(T,　a));　　　　　　　　//　move为NFA的move函数
if　(　U　不在　Dstates　中　)
把U作为尚未标记的状态加入Dstates;
Dtran[T,　a]　=　U
}
}
注意，状态s，ε-closure(s)一定包含s
我们先来熟悉上面的操作operation，再来看上面的算法

ε-closure(0)　=　{0,　1,　2,　4,　7}　　　//　从0状态出发的，input　symbol为ε的所有状态的集合
ε-closure(3)　=　{1,　2,　3,　4,　6,　7}
ε-closure(8)　=　{8}
ε-closure(　{3,　8}　)　=　ε-closure(3)　U　ε-closure(8)　=　{1,　2,　3,　4,　6,　7,　8}
move(0,a)　=　空
move(7,a)　=　{8}
move(8,b)　=　{9}
move(　{0,　1,　2,　4,　7},　a)　=　move(0,a)　U　move(1,a)　U　move(2,a)　U　move(4,a)　U　move(7,a)　=　{3,　8}
现在可以回去理解一下算法了。
这里再说说求ε-closure(T)的算法：
把T的所有状态压入stack(栈);
ε-closure(T)的初始值为　T　中的所有元素　;　　//　也就是一定包含他们本身
while(　栈非空　)　{
弹出栈顶元素　t　;
for(　每个属于　move(t,　ε)　的状态　u　){
if(　u　不在　ε-closure(T)　中　){
u　加入　ε-closure(T);
把　u　入栈;
}
}
}
下面对上图如何使用Set Construction算法来构建DFA做一个详细的描述：
1. 初始化Dstates 把集合 ε-closure(s0) = {0, 1, 2, 4, 7}作为第一个状态，设此状态为 A
2. 现在转化，input symbol {a, b}，因此，求：
ε-closure(move(A, a));
ε-closure(move(A, b));
这里会得到2个状态
ε-closure(move(A, a)) = {1, 2, 3, 4, 6, 7, 8},设其为 B
ε-closure(move(A, b)) = {1, 2, 4, 5, 6, 7}, 设其为C
B，C放入Dstates
改写 Dtrans
最终得到的 Dtrans 为：
A = {0, 1, 2, 4, 7}
B = {1, 2, 3, 4, 6, 7, 8}
C = {1, 2, 4, 5, 6, 7}
D = {1, 2, 4, 5, 6, 7, 9}

因此，NFA转化成为DFA：

 
=========================================
DFA的状态

struct DFA_State
        {
            set content;
            bool                   bFlag;
#ifdef _DEBUG
            uint                   idx;
#endif
            DFA_State(const set& x) : content(x), bFlag(false)
            {
#ifdef _DEBUG
                idx = inc();
#endif
            }
            inline const bool operator==(const DFA_State& x)const
            {
                if (&x == this) return true;
                return content == x.content;
            }
#ifdef _DEBUG
            inline uint inc()
            {
                static uint i = 0;
                return i++;
            }
#endif
        };

  struct DFA_Edge
        {
            struct
            {
                Char_Type   char_value;
                String_Type string_value;
            }data;
            enum Edge_Type
            {
                TUnknown = 0,
                TNot     = 1,
                TChar    = 2,
                TString  = 4
            };
            uchar edge_type;
            DFA_State* pFrom;
            DFA_State* pTo;
            DFA_Edge(const Char_Type& x, bool bNot, DFA_State* pFrom, DFA_State* pTo) : pFrom(pFrom), pTo(pTo)
            {
                data.char_value = x;
                edge_type = bNot ? (TChar | TNot) : TChar;
            }
            DFA_Edge(const String_Type& x, bool bNot, DFA_State* pFrom, DFA_State* pTo) : pFrom(pFrom), pTo(pTo)
            {
                data.string_value = x;
                edge_type = bNot ? (TString | TNot) : TString;
            }
            inline const bool isNot()const
            {
                return (edge_type & TNot) == TNot;
            }
            inline const bool isChar()const
            {
                return (edge_type & TChar) == TChar;
            }
            inline const bool isString()const
            {
                return (edge_type & TString) == TString;
            }
            const Edge_Type edgeType()const
            {
                if (isChar()) return TChar;
                else if (isString()) return TString;
                else return TUnknown;
            }
            const bool operator<(const DFA_Edge& x)const
            {
                return (ulong)pFrom + pTo < (ulong)x.pFrom + x.pTo;
            }
            const bool operator==(const DFA_Edge& x)const
            {
                return pFrom == x.pFrom && pTo == x.pTo;
            }
        };

DFA_State*      pDFAStart;
set pDFAEnds;
set   dfa_Edges;

  void epsilonClosure(const set& k, EpsilonClosureInfo& info)
        {
            for (typename set::const_iterator i = k.begin(), m = k.end(); i != m; ++i)
            {
                info.states.insert(*i);
                set tmp;
                tmp.insert(*i);
                while (!tmp.empty())
                {
                    EpsilonNFA_State* pState = *tmp.begin();
                    for (typename vector::const_iterator j = epsilonNFA_Edges[pState].begin(), n = epsilonNFA_Edges[pState].end(); j != n; ++j)
                    {
                        if (j->isEpsilon())
                        {
                            if (info.states.insert(j->pTo).second) tmp.insert(j->pTo);
                        }
                        else if (j->isChar()) info.chars.insert(pair(j->data.char_value, j->isNot()));
                        else if (j->isString()) info.strings.insert(pair(j->data.string_value, j->isNot()));
                    }
                    tmp.erase(pState);
                }
            }
        }

  struct EpsilonClosureInfo
        {
            set        states;
            set >   chars;
            set > strings;
            EpsilonClosureInfo() {}
            EpsilonClosureInfo(const set& states,
                               const set >& chars,
                               const set >& strings)
                               : states(states)
                               , chars(chars)
                               , strings(strings) {}
            EpsilonClosureInfo(const EpsilonClosureInfo& x)
            {
                states  = x.states;
                chars   = x.chars;
                strings = x.strings;
            }
        };

   set move(const DFA_State& t, const Char_Type& c, bool bNot)
        {
            set result;
            for (typename set::const_iterator i = t.content.begin(), m = t.content.end(); i != m; ++i)
            {
                for (typename vector::const_iterator j = epsilonNFA_Edges[*i].begin(), n = epsilonNFA_Edges[*i].end(); j != n; ++j)
                {
                    if (j->isChar() && j->data.char_value == c && j->isNot() == bNot) result.insert(j->pTo);
                }
            }
            return result;
        }
        set move(const DFA_State& t, const String_Type& s, bool bNot)
        {
            set result;
            for (typename set::const_iterator i = t.content.begin(), m = t.content.end(); i != m; ++i)
            {
                for (typename vector::const_iterator j = epsilonNFA_Edges[*i].begin(), n = epsilonNFA_Edges[*i].end(); j != n; ++j)
                {
                    if (j->isString() && j->data.string_value == s && j->isNot() == bNot) result.insert(j->pTo);
                }
            }
            return result;
        }

   void buildDFA()
        {
            set start;
            start.insert(pEpsilonStart);
            typedef pair c_type;
            map > c;
            queue c2;
            pDFAStart = DFA_State_Alloc::allocate();
            EpsilonClosureInfo info;
            epsilonClosure(start, info);
            construct(pDFAStart, info.states);
            c_type ct(pDFAStart, info);
            c[info.states.size()].push_back(ct);
            c2.push(ct);
            if (isEndDFAStatus(pDFAStart)) pDFAEnds.insert(pDFAStart);
            context.dfa_States.insert(pDFAStart);
            while (!c2.empty())
            {
                DFA_State* t = c2.front().first;
                set > chars = c2.front().second.chars;
                set > strings = c2.front().second.strings;
                t->bFlag = true;
                for (typename set >::const_iterator i = chars.begin(), m = chars.end(); i != m; ++i)
                {
                    EpsilonClosureInfo info;
                    epsilonClosure(move(*t, i->first, i->second), info);
                    DFA_State* p = getDFAState(info.states, c);
                    if (p) // 如果这个状态已存在
                    {
                        dfa_Edges.insert(DFA_Edge(i->first, i->second, t, p));
                    }
                    else
                    {
                        DFA_State* pState = DFA_State_Alloc::allocate();
                        construct(pState, info.states);
                        context.dfa_States.insert(pState);
                        if (isEndDFAStatus(pState)) pDFAEnds.insert(pState);
                        c_type ct(pState, info);
                        c[info.states.size()].push_back(ct);
                        c2.push(ct);
                        dfa_Edges.insert(DFA_Edge(i->first, i->second, t, pState));
                    }
                }
                for (typename set >::const_iterator i = strings.begin(), m = strings.end(); i != m; ++i)
                {
                    EpsilonClosureInfo info;
                    epsilonClosure(move(*t, i->first, i->second), info);
                    DFA_State* p = getDFAState(info.states, c);
                    if (p) // 如果这个状态已存在
                    {
                        dfa_Edges.insert(DFA_Edge(i->first, i->second, t, p));
                    }
                    else
                    {
                        DFA_State* pState = DFA_State_Alloc::allocate();
                        construct(pState, info.states);
                        context.dfa_States.insert(pState);
                        if (isEndDFAStatus(pState)) pDFAEnds.insert(pState);
                        c_type ct(pState, info);
                        c[info.states.size()].push_back(ct);
                        c2.push(ct);
                        dfa_Edges.insert(DFA_Edge(i->first, i->second, t, pState));
                    }
                }
                c2.pop();
            }
        }

 void printDFA()
        {
            printf("---------- DFA Start ----------n");
            set tmp;
            for (typename set::const_iterator i = dfa_Edges.begin(), m = dfa_Edges.end(); i != m; ++i)
            {
                printf("%03d -> %03d", i->pFrom->idx, i->pTo->idx);
                switch (i->edgeType())
                {
                case DFA_Edge::TChar:
                    printf("(%c)", i->data.char_value);
                    break;
                case DFA_Edge::TString:
                    printf("(%s)", i->data.string_value.c_str());
                    break;
                default:
                    break;
                }
                if (i->isNot()) printf("(not)");
                printf("n");
                tmp.insert(i->pFrom);
                tmp.insert(i->pTo);
            }
            printf("start: %03d -> ends: ", pDFAStart->idx);
            for (typename set::const_iterator i = pDFAEnds.begin(), m = pDFAEnds.end(); i != m; ++i)
            {
                printf("%03d ", (*i)->idx);
            }
            printf("n");
#if DEBUG_LEVEL == 3
            printf("-------------------------------n");
            for (typename set::const_iterator i = tmp.begin(), m = tmp.end(); i != m; ++i)
            {
                printf("State: %03dn", (*i)->idx);
                for (typename set::const_iterator j = (*i)->content.begin(), n = (*i)->content.end(); j != n; ++j)
                {
                    printf("%03d ", (*j)->idx);
                }
                printf("n");
            }
#endif
            printf("----------- DFA End -----------n");
        }

Rule_Type::Context context;
Rule_Type a('a', context), b('b', context), d('d', context);
Rule_Type result = (a - d).opt() + (+b | !(a + b));
result.buildDFA();
#ifdef _DEBUG
result.printEpsilonNFA();
result.printDFA();
#endif

文章来自http://www.360doc.com/content/09/0219/10/98111_2586955.shtml
以及http://hi.baidu.com/tcet030840zxp/item/c923fe885ddd0329100ef3ec

Mar(y|k|cus) is son of bitch.

PUSH a To automaton stack
PUSH b To automaton stack
UNION
STAR
PUSH c To automaton stack
CONCAT
PUSH d To automaton stack
CONCAT
POP result

POP T from automaton stack
CREATE state A, B
ADD transition from A to B with 'ε'
ADD transition from A to T.entry with 'ε'
ADD transition from T.exit to A with 'ε'
ADD transition from T.exit to B with 'ε'
ADD state A, B to T
PUSH T to automaton stack

POP F, S from automaton stack
ADD transition from F.exit to S.entry with 'ε'
JOIN S to F
SET F.exit = S.exit
SET F.inputSet += S.inputSet
PUSH F to automaton stack

POP F, S from automaton stack
CREATE state A, B
ADD transition from A to F.entry with 'ε'
ADD transition from A to S.entry with 'ε'
ADD transition from T.exit to B with 'ε'
ADD transition from T.exit to B with 'ε'
JOIN S to F
ADD state A, B to T
SET F.exit = S.exit
SET F.inputSet += S.inputSet
PUSH F to automaton stack

/* Regular expression implementation.
 * Supports only ( | ) * + ?.  No escapes.
 * Compiles to NFA and then simulates NFA
 * using Thompson's algorithm.
 *
 * See also http://swtch.com/~rsc/regexp/ and
 * Thompson, Ken.  Regular Expression Search Algorithm,
 * Communications of the ACM 11(6) (June 1968), pp. 419-422.
 * 
 * Copyright (c) 2007 Russ Cox.
 * Can be distributed under the MIT license, see bottom of file.
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
/*
 * Convert infix regexp re to postfix notation.
 * Insert . as explicit concatenation operator.
 * Cheesy parser, return static buffer.
 */
char*
re2post(char *re)
{
	int nalt, natom;
	static char buf[8000];
	char *dst;
	struct {
		int nalt;
		int natom;
	} paren[100], *p;
	p = paren;
	dst = buf;
	nalt = 0;
	natom = 0;
	if(strlen(re) >= sizeof buf/2)
		return NULL;
	for(; *re; re++){
		switch(*re){
		case '(':
			if(natom > 1){
				--natom;
				*dst++ = '.';
			}
			if(p >= paren+100)
				return NULL;
			p->nalt = nalt;
			p->natom = natom;
			p++;
			nalt = 0;
			natom = 0;
			break;
		case '|':
			if(natom == 0)
				return NULL;
			while(--natom > 0)
				*dst++ = '.';
			nalt++;
			break;
		case ')':
			if(p == paren)
				return NULL;
			if(natom == 0)
				return NULL;
			while(--natom > 0)
				*dst++ = '.';
			for(; nalt > 0; nalt--)
				*dst++ = '|';
			--p;
			nalt = p->nalt;
			natom = p->natom;
			natom++;
			break;
		case '*':
		case '+':
		case '?':
			if(natom == 0)
				return NULL;
			*dst++ = *re;
			break;
		default:
			if(natom > 1){
				--natom;
				*dst++ = '.';
			}
			*dst++ = *re;
			natom++;
			break;
		}
	}
	if(p != paren)
		return NULL;
	while(--natom > 0)
		*dst++ = '.';
	for(; nalt > 0; nalt--)
		*dst++ = '|';
	*dst = 0;
	return buf;
}
/*
 * Represents an NFA state plus zero or one or two arrows exiting.
 * if c == Match, no arrows out; matching state.
 * If c == Split, unlabeled arrows to out and out1 (if != NULL).
 * If c < 256, labeled arrow with character c to out.
 */
enum
{
	Match = 256,
	Split = 257
};
typedef struct State State;
struct State
{
	int c;
	State *out;
	State *out1;
	int lastlist;
};
State matchstate = { Match };	/* matching state */
int nstate;
/* Allocate and initialize State */
State*
state(int c, State *out, State *out1)
{
	State *s;
	nstate++;
	s = malloc(sizeof *s);
	s->lastlist = 0;
	s->c = c;
	s->out = out;
	s->out1 = out1;
	return s;
}
/*
 * A partially built NFA without the matching state filled in.
 * Frag.start points at the start state.
 * Frag.out is a list of places that need to be set to the
 * next state for this fragment.
 */
typedef struct Frag Frag;
typedef union Ptrlist Ptrlist;
struct Frag
{
	State *start;
	Ptrlist *out;
};
/* Initialize Frag struct. */
Frag
frag(State *start, Ptrlist *out)
{
	Frag n = { start, out };
	return n;
}
/*
 * Since the out pointers in the list are always 
 * uninitialized, we use the pointers themselves
 * as storage for the Ptrlists.
 */
union Ptrlist
{
	Ptrlist *next;
	State *s;
};
/* Create singleton list containing just outp. */
Ptrlist*
list1(State **outp)
{
	Ptrlist *l;
	l = (Ptrlist*)outp;
	l->next = NULL;
	return l;
}
/* Patch the list of states at out to point to start. */
void
patch(Ptrlist *l, State *s)
{
	Ptrlist *next;
	for(; l; l=next){
		next = l->next;
		l->s = s;
	}
}
/* Join the two lists l1 and l2, returning the combination. */
Ptrlist*
append(Ptrlist *l1, Ptrlist *l2)
{
	Ptrlist *oldl1;
	oldl1 = l1;
	while(l1->next)
		l1 = l1->next;
	l1->next = l2;
	return oldl1;
}
/*
 * Convert postfix regular expression to NFA.
 * Return start state.
 */
State*
post2nfa(char *postfix)
{
	char *p;
	Frag stack[1000], *stackp, e1, e2, e;
	State *s;
	// fprintf(stderr, "postfix: %sn", postfix);
	if(postfix == NULL)
		return NULL;
	#define push(s) *stackp++ = s
	#define pop() *--stackp
	stackp = stack;
	for(p=postfix; *p; p++){
		switch(*p){
		default:
			s = state(*p, NULL, NULL);
			push(frag(s, list1(&s->out)));
			break;
		case '.':	/* catenate */
			e2 = pop();
			e1 = pop();
			patch(e1.out, e2.start);
			push(frag(e1.start, e2.out));
			break;
		case '|':	/* alternate */
			e2 = pop();
			e1 = pop();
			s = state(Split, e1.start, e2.start);
			push(frag(s, append(e1.out, e2.out)));
			break;
		case '?':	/* zero or one */
			e = pop();
			s = state(Split, e.start, NULL);
			push(frag(s, append(e.out, list1(&s->out1))));
			break;
		case '*':	/* zero or more */
			e = pop();
			s = state(Split, e.start, NULL);
			patch(e.out, s);
			push(frag(s, list1(&s->out1)));
			break;
		case '+':	/* one or more */
			e = pop();
			s = state(Split, e.start, NULL);
			patch(e.out, s);
			push(frag(e.start, list1(&s->out1)));
			break;
		}
	}
	e = pop();
	if(stackp != stack)
		return NULL;
	patch(e.out, &matchstate);
	return e.start;
#undef pop
#undef push
}
typedef struct List List;
struct List
{
	State **s;
	int n;
};
List l1, l2;
static int listid;
void addstate(List*, State*);
void step(List*, int, List*);
/* Compute initial state list */
List*
startlist(State *start, List *l)
{
	l->n = 0;
	listid++;
	addstate(l, start);
	return l;
}
/* Check whether state list contains a match. */
int
ismatch(List *l)
{
	int i;
	for(i=0; i<l->n; i++)
		if(l->s[i] == &matchstate)
			return 1;
	return 0;
}
/* Add s to l, following unlabeled arrows. */
void
addstate(List *l, State *s)
{
	if(s == NULL || s->lastlist == listid)
		return;
	s->lastlist = listid;
	if(s->c == Split){
		/* follow unlabeled arrows */
		addstate(l, s->out);
		addstate(l, s->out1);
		return;
	}
	l->s[l->n++] = s;
}
/*
 * Step the NFA from the states in clist
 * past the character c,
 * to create next NFA state set nlist.
 */
void
step(List *clist, int c, List *nlist)
{
	int i;
	State *s;
	listid++;
	nlist->n = 0;
	for(i=0; i<clist->n; i++){
		s = clist->s[i];
		if(s->c == c)
			addstate(nlist, s->out);
	}
}
/* Run NFA to determine whether it matches s. */
int
match(State *start, char *s)
{
	int i, c;
	List *clist, *nlist, *t;
	clist = startlist(start, &l1);
	nlist = &l2;
	for(; *s; s++){
		c = *s & 0xFF;
		step(clist, c, nlist);
		t = clist; clist = nlist; nlist = t;	/* swap clist, nlist */
	}
	return ismatch(clist);
}
int
main(int argc, char **argv)
{
	int i;
	char *post;
	State *start;
	if(argc < 3){
		fprintf(stderr, "usage: nfa regexp string...n");
		return 1;
	}
	post = re2post(argv[1]);
	if(post == NULL){
		fprintf(stderr, "bad regexp %sn", argv[1]);
		return 1;
	}
	start = post2nfa(post);
	if(start == NULL){
		fprintf(stderr, "error in post2nfa %sn", post);
		return 1;
	}
	l1.s = malloc(nstate*sizeof l1.s[0]);
	l2.s = malloc(nstate*sizeof l2.s[0]);
	for(i=2; i<argc; i++)
		if(match(start, argv[i]))
			printf("%sn", argv[i]);
	return 0;
}
/*
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the
 * Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute,
 * sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall
 * be included in all copies or substantial portions of the
 * Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
 * KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
 * PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS
 * OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

2016.1 链接已更新

其实就是自己组的啦~有需要的拿去看吧，还有很多需要完善的地方，拿了M奖也很是惊喜，哈哈~
Team #18836 The Ultimate Brownie Pan
 
 

本人对linux环境很不熟悉，今天做操作系统作业要在linux下用信号量以及pthread编程，使用codeblocks这个IDE，然后链接报错
/tmp/ccMNPEfl.o：在函数‘init_semaphores()’中：
source.cpp:(.text+0x212)：对‘sem_init’未定义的引用
source.cpp:(.text+0x22e)：对‘sem_init’未定义的引用
source.cpp:(.text+0x24a)：对‘sem_init’未定义的引用
/tmp/ccMNPEfl.o：在函数‘ProducerProcess(void*)’中：
source.cpp:(.text+0x2a8)：对‘sem_wait’未定义的引用
source.cpp:(.text+0x2b4)：对‘sem_wait’未定义的引用
source.cpp:(.text+0x31c)：对‘sem_post’未定义的引用
source.cpp:(.text+0x328)：对‘sem_post’未定义的引用
/tmp/ccMNPEfl.o：在函数‘ConsumerProcess(void*)’中：
source.cpp:(.text+0x34c)：对‘sem_wait’未定义的引用
source.cpp:(.text+0x358)：对‘sem_wait’未定义的引用
source.cpp:(.text+0x3bd)：对‘sem_post’未定义的引用
source.cpp:(.text+0x3c9)：对‘sem_post’未定义的引用
/tmp/ccMNPEfl.o：在函数‘init_threads()’中：
source.cpp:(.text+0x417)：对‘pthread_create’未定义的引用
source.cpp:(.text+0x431)：对‘pthread_join’未定义的引用
source.cpp:(.text+0x45c)：对‘pthread_create’未定义的引用
source.cpp:(.text+0x476)：对‘pthread_join’未定义的引用
collect2: 错误： ld 返回 1
后来查了半天发现是链接器要加上参数 -pthread
记录一下，说不定以后又忘了呢。。~