2. 程式人生 > >編譯器架構的王者LLVM——（4）簡單的詞法和語法分析

編譯器架構的王者LLVM——（4）簡單的詞法和語法分析

阿新 • • 發佈：2019-02-10

LLVM平臺，短短几年間，改變了眾多程式語言的走向，也催生了一大批具有特色的程式語言的出現，不愧為編譯器架構的王者，也榮獲2012年ACM軟體系統獎 —— 題記

簡單的詞法和語法分析

Lex和Yacc真是太好用了，非常方便我們構建一門語言的分析程式。

如果你對Lex和Yacc不瞭解的話，建議先看下我之前寫的兩篇文章，分別介紹了Lex和Yacc的用法。

FLex建立一門語言的詞法分析程式

我們建立的是一門程式語言，那麼詞法分析程式就不能像做實驗一樣那麼草率，必須考慮周全，一般一門語言的詞法分析程式大概需要囊括如下的幾個方面：

識別關鍵字、識別識別符號、識別基本常量（數字、浮點數、字串、字元）、識別註釋、識別運算子

這些都是非常重要的，而且是一門語言語法中必不可少的部分。

於是RedApple的詞法分析部分，我就設計成了這樣：

%{
#include <string>
#include "Model/nodes.h"
#include <list>
using namespace std;

#include "redapple_parser.hpp"
#include "StringEscape.h"

#define SAVE_TOKEN     yylval.str = maketoken(yytext, yyleng)
#define SAVE_STRING    yylval.str = makestring(yytext, yyleng, 2)
 

#define SAVE_STRING_NC yylval.str = makestring(yytext, yyleng, 3)
extern "C" int yywrap() { return 1; }
char* maketoken(const char* data, int len);
char* makestring(const char* data, int len, int s);

%}

%option yylineno

%%

"/*"([^\*]|(\*)*[^\*/])*(\*)*"*/" ; /* 就是這種註釋 */ 

#[^\n]*\n               ; /* 井號註釋 */ 
 

"//"[^\n]*\n            ; /* 雙線註釋 */ 

[ \t\v\n\f]             ; /* 過濾空白字元 */


"=="                    return CEQ;
"<="                    return CLE;
">="                    return CGE;
"!="                    return CNE;

"<"                     return '<';
"="                     return '=';
">"                     return '>';
"("                     return '(';
")"                     return ')';
"["                     return '[';
"]"                     return ']';
"{"                     return '{';
"}"                     return '}';
"."                     return '.';
","                     return ',';
":"                     return ':';
";"                     return ';';
"+"                     return '+';
"-"                     return '-';
"*"                     return '*';
"/"                     return '/';
"%"                     return '%';
"^"                     return '^';
"&"                     return '&';
"|"                     return '|';
"~"                     return '~';

    /* 巨集運算子 */
"@"                     return '@';
",@"                    return MBK;

    /* 下面宣告要用到的關鍵字 */

    /* 控制流 */
"if"                    return IF;
"else"                  return ELSE;
"while"                 return WHILE;
"do"                    return DO;
"goto"                  return GOTO;
"for"                   return FOR;
"foreach"               return FOREACH;

    /* 退出控制 */
"break"|"continue"|"exit"   SAVE_TOKEN; return KWS_EXIT;

"return"                return RETURN;

    /* 特殊運算子 */
"new"                   return NEW;
"this"                  return THIS;

    /* 特殊定義 */
"delegate"              return DELEGATE;
"def"                   return DEF;
"define"                return DEFINE;
"import"                return IMPORT;
"using"                 return USING;
"namespace"             return NAMESPACE;

"try"|"catch"|"finally"|"throw"  SAVE_TOKEN; return KWS_ERROR; /* 異常控制 */

"null"|"true"|"false"               SAVE_TOKEN; return KWS_TSZ; /* 特殊值 */

"struct"|"enum"|"union"|"module"|"interface"|"class"     SAVE_TOKEN; return KWS_STRUCT; /* 結構宣告 */

"public"|"private"|"protected"  SAVE_TOKEN; return KWS_FWKZ; /* 訪問控制 */

"const"|"static"|"extern"|"virtual"|"abstract"|"in"|"out"        SAVE_TOKEN; return KWS_FUNC_XS; /* 函式修飾符 */

"void"|"double"|"int"|"float"|"char"|"bool"|"var"|"auto"  SAVE_TOKEN; return KWS_TYPE; /* 基本型別 */

[a-zA-Z_][a-zA-Z0-9_]*  SAVE_TOKEN; return ID; /* 識別符號 */

[0-9]*\.[0-9]*          SAVE_TOKEN; return DOUBLE;
[0-9]+                  SAVE_TOKEN; return INTEGER;

\"(\\.|[^\\"])*\"       SAVE_STRING; return STRING; /* 字串 */
@\"(\\.|[^\\"])*\"      SAVE_STRING_NC; return STRING; /* 無轉義字串 */
\'(\\.|.)\'             SAVE_STRING; return CHAR;   /* 字元 */

.                       printf("Unknown Token!\n"); yyterminate();

%%


char* maketoken(const char* data, int len) {
    char* str = new char[len+1];
    strncpy(str, data, len);
    str[len] = 0;
    return str;
}

char* makestring(const char* data, int len, int s) {
    char* str = new char[len-s+1];
    strncpy(str, data+s-1, len-s);
    str[len-s] = 0;
    if (s == 3) return str;
    printf("source: %s\n",str);
    char* ans = CharEscape(str);
    printf("escape: %s\n",ans);
    delete[] str; 
    return ans; 
}

看起來非常的長，但主要多的就是枚舉了大量的關鍵字和運算子，當然，這個你在開發一門語言的前期，不用面面俱到，可以選自己用到的先寫，不足的再日後補充。

要注意，這裡最難的應該就是：

"/*"([^\*]|(\*)*[^\*/])*(\*)*"*/" ; /* 就是這種註釋 */

乍看起來，非常恐怖的正則式，但其實就是在列舉多種可能情況，來保障註釋範圍的正確性。

"/*"   (  [^\*]   |   (\*)* [^\*/]   )*   (\*)*    "*/" ; /* 就是這種註釋 */

用Bison建立通用的語法分析程式

這裡我編寫的是類C語言的語法，要注意的是，很多情況會造成規約-規約衝突和移入-規約衝突。這裡我簡要介紹一個bison的工作原理。

這種演算法在編譯原理中，被稱為LALR(1)分析法，是自底向上規約的演算法之一，而且又會向前看一個token，Bison中的每一行，被稱為一個產生式（或BNF正規化）

例如下面這行：

def_module_statement : KWS_STRUCT ID '{' def_statements '}'

左邊的是要規約的節點， 冒號右邊是描述這個語法節點是用哪些節點產生的。
這是一個結構體定義的語法描述，KWS_STRUCT是終結符，來自Lex裡的元素，看了上面的Lex描述，你應該能找到它的定義：

"struct"|"enum"|"union"|"module"|"interface"|"class"     SAVE_TOKEN; return KWS_STRUCT; /* 結構宣告 */

其實就是可能的一些關鍵字。而def_statements是另外的語法節點，由其他定義得來。

規約-規約衝突，是說，在當前產生式結束後，後面跟的元素還確定的情況下，能夠規約到兩個不同的語法節點:

def_module_statement : KWS_STRUCT ID '{' def_statements '}' ;
def_class_statement : KWS_STRUCT ID '{' def_statements '}' ;

statement : def_module_statement ';' 
          | def_class_statement ';' 
          ;

以上文法便會產生規約-規約衝突，這是嚴重的定義錯誤，必須加以避免。
注意，我為了體現這個語法的錯誤，特意加上了上下文環境，不是說一樣的語法定義會產生規約規約衝突，而是說後面可能跟的終結符都一樣時，（在這裡是’;’）才會產生規約規約衝突，所以避免這種問題也簡單，就是把相似的語法節點合併在一起就可以了。

說道移入-規約衝突，就要談起if-else的搖擺問題：

if_state : IF '(' expr ')' statement 
         | IF '(' expr ')' statement ELSE statement 
         ;

statement : if_state
          | ...
          ;

正如這個定義一樣，在if的前半部識別完成後，下一個元素是ELSE終結符，此時可以規約，可以移入
說規約合法的理由是，if_state也是statement，而if第二條statement後面就是ELSE。
根據演算法，這裡規約是合理的，而移入同樣是合理的。

為了避免這種衝突，一般Bison會優先選擇移入，這樣ELSE會和最近的IF匹配。
所以說，移入-規約衝突在你清楚的知道是哪的問題的時候，可以不加處理。但未期望的移入-規約衝突有可能讓你的分析器不正確工作，這點還需要注意。

下面是我的Bison配置檔案：

%{
#include "Model/nodes.h"
#include <list>
using namespace std;

#define YYERROR_VERBOSE 1

Node *programBlock; /* the top level root node of our final AST */

extern int yylex();
extern int yylineno;
extern char* yytext;
extern int yyleng;

void yyerror(const char *s);

%}



/* Represents the many different ways we can access our data */

%union {
    Node *nodes;
    char *str;
    int token;
}



/* Define our terminal symbols (tokens). This should

   match our tokens.l lex file. We also define the node type

   they represent.

 */

%token <str> ID INTEGER DOUBLE
%token <token> CEQ CNE CGE CLE MBK
%token <token> '<' '>' '=' '+' '-' '*' '/' '%' '^' '&' '|' '~' '@'
%token <str> STRING CHAR
%token <token> IF ELSE WHILE DO GOTO FOR FOREACH  
%token <token> DELEGATE DEF DEFINE IMPORT USING NAMESPACE
%token <token> RETURN NEW THIS 
%token <str> KWS_EXIT KWS_ERROR KWS_TSZ KWS_STRUCT KWS_FWKZ KWS_FUNC_XS KWS_TYPE

/* 
   Define the type of node our nonterminal symbols represent.
   The types refer to the %union declaration above. Ex: when
   we call an ident (defined by union type ident) we are really
   calling an (NIdentifier*). It makes the compiler happy.
 */

%type <nodes> program
%type <nodes> def_module_statement
%type <nodes> def_module_statements
%type <nodes> def_statement
%type <nodes> def_statements
%type <nodes> for_state
%type <nodes> if_state
%type <nodes> while_state
%type <nodes> statement
%type <nodes> statements
%type <nodes> block
%type <nodes> var_def
%type <nodes> func_def
%type <nodes> func_def_args
%type <nodes> func_def_xs 
%type <nodes> numeric
%type <nodes> expr
%type <nodes> call_arg 
%type <nodes> call_args 
%type <nodes> return_state

//%type <token> operator 這個設計容易引起規約衝突，捨棄
/* Operator precedence for mathematical operators */


%left '~'
%left '&' '|'
%left CEQ CNE CLE CGE '<' '>' '='
%left '+' '-'
%left '*' '/' '%' '^'
%left '.'
%left MBK '@'

%start program

%%

program : def_statements { programBlock = Node::getList($1); }
        ;

def_module_statement : KWS_STRUCT ID '{' def_statements '}' { $$ = Node::make_list(3, StringNode::Create($1), StringNode::Create($2), $4); }
                     | KWS_STRUCT ID ';' { $$ = Node::make_list(3, StringNode::Create($1), StringNode::Create($2), Node::Create()); }
                     ;

def_module_statements  : def_module_statement { $$ = Node::getList($1); }
                       | def_module_statements def_module_statement { $$ = $1; $$->addBrother(Node::getList($2)); }
                       ;

func_def_xs : KWS_FUNC_XS { $$ = StringNode::Create($1); }
            | func_def_xs KWS_FUNC_XS {$$ = $1; $$->addBrother(StringNode::Create($2)); }
            ;

def_statement : var_def ';' { $$ = $1; }
              | func_def 
              | def_module_statement 
              | func_def_xs func_def { $$ = $2; $2->addBrother(Node::getList($1)); } 
              ;

def_statements : def_statement { $$ = Node::getList($1); }
               | def_statements def_statement { $$ = $1; $$->addBrother(Node::getList($2)); }
               ;

statements : statement { $$ = Node::getList($1); }
           | statements statement { $$ = $1; $$->addBrother(Node::getList($2)); }
           ;

statement : def_statement 
          | expr ';' { $$ = $1; } 
          | block 
          | if_state
          | while_state
          | for_state
          | return_state
          ;

if_state : IF '(' expr ')' statement { $$ = Node::make_list(3, StringNode::Create("if"), $3, $5); }
         | IF '(' expr ')' statement ELSE statement { $$ = Node::make_list(4, StringNode::Create("if"), $3, $5, $7); }
         ;

while_state : WHILE '(' expr ')' statement { $$ = Node::make_list(3, StringNode::Create("while"), $3, $5); }
            ;

for_state : FOR '(' expr ';' expr ';' expr ')' statement { $$ = Node::make_list(5, StringNode::Create("for"), $3, $5, $7, $9); }
          | FOR '(' var_def ';' expr ';' expr ')' statement { $$ = Node::make_list(5, StringNode::Create("for"), Node::Create($3), $5, $7, $9); }
          ;

return_state : RETURN ';' { $$ = StringNode::Create("return"); }
             | RETURN expr ';' { $$ = StringNode::Create("return"); $$->addBrother($2); }              

block : '{' statements '}' { $$ = Node::Create($2); }
      | '{' '}' { $$ = Node::Create(); }
      ; 

var_def : KWS_TYPE ID { $$ = Node::make_list(3, StringNode::Create("set"), StringNode::Create($1), StringNode::Create($2)); }
        | ID ID { $$ = Node::make_list(3, StringNode::Create("set"), StringNode::Create($1), StringNode::Create($2)); }
        | KWS_TYPE ID '=' expr { $$ = Node::make_list(4, StringNode::Create("set"), StringNode::Create($1), StringNode::Create($2), $4); }
        | ID ID '=' expr { $$ = Node::make_list(4, StringNode::Create("set"), StringNode::Create($1), StringNode::Create($2), $4); }
        ;

func_def : ID ID '(' func_def_args ')' block
            { $$ = Node::make_list(5, StringNode::Create("function"), StringNode::Create($1), StringNode::Create($2), $4, $6); }
         | KWS_TYPE ID '(' func_def_args ')' block
            { $$ = Node::make_list(5, StringNode::Create("function"), StringNode::Create($1), StringNode::Create($2), $4, $6); }
         | ID ID '(' func_def_args ')' ';'
            { $$ = Node::make_list(5, StringNode::Create("function"), StringNode::Create($1), StringNode::Create($2), $4); }
         | KWS_TYPE ID '(' func_def_args ')' ';'
            { $$ = Node::make_list(5, StringNode::Create("function"), StringNode::Create($1), StringNode::Create($2), $4); }
         ;

func_def_args : var_def { $$ = Node::Create(Node::Create($1)); }
              | func_def_args ',' var_def { $$ = $1; $$->addChildren(Node::Create($3)); }
              | %empty  { $$ = Node::Create(); }
              ;

numeric : INTEGER { $$ = IntNode::Create($1); }
        | DOUBLE { $$ = FloatNode::Create($1); }
        ;

expr : expr '=' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("="), $1, $3); }
     | ID '(' call_args ')' { $$ = Node::make_list(2, StringNode::Create("call"), StringNode::Create($1)); $$->addBrother($3); }
     | ID { $$ = IDNode::Create($1); }
     | numeric { $$ = $1; }
     | STRING { $$ = StringNode::Create($1); }
     | KWS_TSZ 
     | NEW ID '(' call_args ')' { $$ = Node::make_list(3, StringNode::Create("new"), StringNode::Create($2), $4); }
     | expr CEQ expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("=="), $1, $3); }
     | expr CNE expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("!="), $1, $3); }
     | expr CLE expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("<="), $1, $3); }
     | expr CGE expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create(">="), $1, $3); }
     | expr '<' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("<"), $1, $3); }
     | expr '>' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create(">"), $1, $3); }
     | expr '+' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("+"), $1, $3); }
     | expr '-' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("-"), $1, $3); }
     | expr '*' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("*"), $1, $3); }
     | expr '/' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("/"), $1, $3); }
     | expr '%' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("%"), $1, $3); }
     | expr '^' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("^"), $1, $3); }
     | expr '&' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("&"), $1, $3); }
     | expr '|' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("|"), $1, $3); }
     | expr '.' expr { $$ = Node::make_list(4, StringNode::Create("opt2"), StringNode::Create("."), $1, $3); }
     | '~' expr { $$ = Node::make_list(4, StringNode::Create("opt1"), StringNode::Create("~"), $2); }
     | '(' expr ')'  /* ( expr ) */  { $$ = $2; }
     ;


call_arg  :  expr { $$ = $1;  }
          |  ID ':' expr { $$ = Node::make_list(3, StringNode::Create(":"), $1, $3); }
          ;

call_args : %empty { $$ = Node::Create(); }
          | call_arg { $$ = Node::getList($1); }
          | call_args ',' call_arg  { $$ = $1; $$->addBrother(Node::getList($3)); }
          ;

%%

void yyerror(const char* s){
    fprintf(stderr, "%s \n", s);    
    fprintf(stderr, "line %d: ", yylineno);
    fprintf(stderr, "text %s \n", yytext);
    exit(1);
}

相關推薦

編譯器架構的王者LLVM——（4）簡單的詞法和語法分析

LLVM平臺，短短几年間，改變了眾多程式語言的走向，也催生了一大批具有特色的程式語言的出現，不愧為編譯器架構的王者，也榮獲2012年ACM軟體系統獎 —— 題記 簡單的詞法和語法分析 Lex和Yacc真是太好用了，非常方便我們構建一門語言的分析程式。

效能測試必備知識（4）- 使用 stress 和 sysstat 分析平均負載過高的場景

做效能測試的必備知識系列，可以看下面連結的文章哦 https://www.cnblogs.com/poloyy/category/1806772.html   stress 介紹 Linux 系統壓力測試工具，這裡通過異常程序模擬平均負載升高的場景   來看看 stress 命令列引數的講

編譯器架構的王者LLVM——（12）使用JIT引擎

LLVM平臺，短短几年間，改變了眾多程式語言的走向，也催生了一大批具有特色的程式語言的出現，不愧為編譯器架構的王者，也榮獲2012年ACM軟體系統獎 —— 題記 使用JIT引擎 LLVM從設計之初就考慮瞭解釋執行的功能,這非常其作為一款跨平臺的中間位

編譯器架構的王者LLVM——（7）函式的翻譯方法

LLVM平臺，短短几年間，改變了眾多程式語言的走向，也催生了一大批具有特色的程式語言的出現，不愧為編譯器架構的王者，也榮獲2012年ACM軟體系統獎 —— 題記 函式的翻譯方法 前面介紹了許多編譯器架構上面的特點，如何組織語法樹、如果多遍掃描語法樹。今天

python（4）- 簡單練習：python實現購物車的優化

list x11 int 退出 .html htm src keyword 結算 簡單版本，鏈接如下： http://www.cnblogs.com/c-x-m/p/7819220.html 購物車程序優化題目要求： 1. 用戶退出時打印商品列表時，按以下格式

CUDA學習筆記（4）- 簡單的影象處理

使用GPU處理影象的速度比使用CPU處理影象的速度要快很多，下面是使用GPU與使用CPU做影象處理速度的對比，對同一個影象做簡單的黑色的混色。 可以看出使用GPU處理大約需要耗時10ms左右，而使用CPU處理大約需要耗時50毫秒左右，CUDA處理影象的速度大約

企業架構研究總結（4）——企業架構與企業架構框架概論

      通過企業架構的發展歷程我們可以看出，經過幾十年的發展業界已經湧現出了很多企業架構以及企業架構框架理論。在本章中，筆者將挑選幾種主要的企業架構和企業架構框架理論進行詳細闡述。需要注意的是，雖然本章定名為“企業架構與企業架構框架”，但是由於企業架構的特性所致，其真實形

ps切圖（4）——簡單工具操作（3）

第一部分：操作路徑 鋼筆工具： 補充：關於錨點的一個基本常識：錨點有空心和實心。 路徑的基本操作技巧： 路徑如何切換為選區：首先要將工作區切換到基本功能，然後路徑面板底部第三個屬性是將路徑切換為選區。這個功能比較重要。 建立錨點： >>> 直接使用滑鼠左

軟工作業（4）：用戶體驗分析——以 “師路南通網站” 為例

學員 androi blog 賬號 移動 用戶登錄 自動 二維 資源獲取 用戶體驗分析：以 “師路南通網站” 為例 一、目標 （1）針對師路南通，開展UX分 PS：對比另外2個學習網站（學生安

Java Web 深入分析（4） Java I/O 深入分析

lock 異步 瓶頸 系統 基本結構 java 同步異步 nio -i I/O問題可以說是現在大部分web系統的瓶頸。我們要了解的java I/O(後面簡稱為（io）) io類庫的基本結構 -磁盤io的工作機制 -網絡io的工作機制 -NIO的工作方式 -同步異步、阻

大資料入門（4）hdfs的shell語法

1、測試hdfs檔案上傳和下載（HDFS shell）     1.0檢視幫助         hadoop fs -help <cmd>     1.1上傳 &n

自動記憶體管理機制（4）- 記憶體分配和回收策略

自動記憶體管理機制（4）- 記憶體分配和回收策略 Java所承諾的自動記憶體管理主要是針對物件記憶體的回收和物件記憶體的分配。 在Java虛擬機器的五塊記憶體空間中，程式計數器、Java虛擬機器棧、本地方法棧記憶體的分配和回收都具有確定性，一般在編譯階段就能確定需要分配的記憶體大小，

尋找“最好”（4）——不等約束和KKT條件

不等約束 　　上篇文章介紹瞭如何在等式約束下使用拉格朗日乘子法，然而真實的世界哪有那麼多等式約束？我們碰到的大多數問題都是不等約束。對於不等約束的優化問題，可以這樣描述： 　　其中f(x)是目標函式，g(x)為不等式約束，h(x)為等式約束，x = x1, x2, …… xk。 　　對於不等約束來說

~雜記（4）：阿里和華為rtos 的接管中斷邏輯探索

1、首先在某晶片的啟動檔案中，給出的中斷向量表全是指向同一個函式。（一開始我以為是錯的，自己改成各個預設中斷服務函式的入口，這樣就成了非接管中斷）。 部分程式碼如下，其中irq_handler就是那個統一的中斷服務函式。他被定義在排程檔案los_dispatch中。 __Vectors:

設計模式（一）——簡單工廠和工廠方法的異同

一、簡單工廠 1.定義： 簡單工廠模式（Simple Factory  Pattern）：又稱為靜態工廠方法（Static Factory Method）模式。它屬於類建立型模式，在簡單工廠模式中，可以根據引數的不同返回不同型別的例項。簡單工廠模式專門定義一個類來負責建立其他的

linux學習筆記之shell程式設計（三）流程控制（4）while迴圈和until迴圈

while迴圈和until迴圈 ###、 while迴圈 不定迴圈，程式碼格式： while [判斷] do something done 指令碼例項1： #!/bin/bash #從1加到

git學習（廖雪峰git網站）（4）---工作區和暫存區

（1）名詞解釋： 工作區（Working Directory） 就是你在電腦裡能看到的目錄，比如你所建的資料夾就是一個工作區； 版本庫（Repository） 工作區有一個隱藏目錄.git，這個不算工作區，而是Git的版本庫。 Git的版本庫裡存了很多東西，其

vue2.0專案實戰（4）生命週期和鉤子函式詳解

最近的專案都使用vue2.0來開發，不得不說，vue真的非常好用，大大減少了專案的開發週期。在踩坑的過程中，因為對vue的生命週期不是特別瞭解，所以有時候會在幾個鉤子函式裡做一些事情，什麼時候做，在哪個函式裡做，我們不清楚。 下面來總結一下vue的生命週期。 vue生命週期簡介 咱們從上圖可以很明顯的看出

四國軍棋引擎開發（4）子力判斷和局面評估初步

1.子力判斷 子力判斷在局面評估中起著非常重要的作用，在前一篇文章中已經介紹了子力判斷的部分，那時相對還比較粗糙，這次會更細緻的分析並優化上一次的不足。 pLineup->type用來代表棋子的型別，這裡是用列舉變數來表示，要注意級別大的變數值小，如40的值是5，39的值是6，

Performanced C++ 經驗規則（4）：靜態和多型，亦敵亦友

這一篇，我們討論C++中靜態和多型的關係。我們都知道，C++並不是一門“動態”語言，雖然它提供了同樣強大於其它動態語言的多型性，但很多時候，我們之所以選擇C++，看重中正是其“靜態”所帶來的High Performance。所謂靜態，通常是指，在程式執行的過程，是“靜止”不變，固定的（特別是記憶體地