一、函數(shù)：

    在Lua中函數(shù)的調(diào)用方式和C語(yǔ)言基本相同，如：print("Hello World")和a = add(x, y)。唯一的差別是，如果函數(shù)只有一個(gè)參數(shù)，并且該參數(shù)的類型為字符串常量或table的構(gòu)造器，那么圓括號(hào)可以省略，如print "Hello World"和f {x = 20, y = 20}。
    Lua為面對(duì)對(duì)象式的調(diào)用也提供了一種特殊的語(yǔ)法--冒號(hào)操作符。表達(dá)式o.foo(o,x)的另一種寫(xiě)法是o:foo(x)。冒號(hào)操作符使調(diào)用o.foo時(shí)將o隱含的作為函數(shù)的第一個(gè)參數(shù)。
    Lua中函數(shù)的聲明方式如下：
    function add(a)
        local sum = 0
        for i, v in ipairs(a) do
            sum = sum + v
        end
        return sum
    end
    在以上聲明中，包含了函數(shù)名(add)，參數(shù)列表(a)，以及函數(shù)體。需要說(shuō)明的是，Lua中實(shí)參和形參的數(shù)量可以不一致，一旦出現(xiàn)這種情況，Lua的處理規(guī)則等同于多重賦值，即實(shí)參多于形參，多出的部分被忽略，如果相反，沒(méi)有被初始化的形參的缺省值為nil。

    1. 多重返回值：
    Lua支持返回多個(gè)結(jié)果值。如：

1 s,e = string.find("Hello Lua users","Lua")
2 print("The begin index is " .. s .. ", the end index is " .. e .. ".");
3 -- The begin index is 7, the end index is 9.

    以上的代碼示例只是演示了如何獲取Lua函數(shù)的多個(gè)返回值，下面的示例將給出如何聲明返回多個(gè)值的Lua函數(shù)。如：

 1 function maximum(a)
 2     local mi = 1
 3     local m = a[mi]
 4     for i, val in ipairs(a) do
 5         if val > m then
 6             mi,m = i,val
 7         end
 8     end
 9     return m,mi
10 end
11 print(maximum{8,10,23,12,5})
12 --23   3

    Lua會(huì)調(diào)整一個(gè)函數(shù)的返回值數(shù)量以適應(yīng)不同的調(diào)用情況。若將函數(shù)調(diào)用作為一條單獨(dú)語(yǔ)句時(shí)，Lua會(huì)丟棄函數(shù)的所有返回值。若將函數(shù)作為表達(dá)式的一部分來(lái)調(diào)用時(shí)，Lua只保留函數(shù)的第一個(gè)返回值。只有當(dāng)一個(gè)函數(shù)調(diào)用是一系列表達(dá)式中的最后一個(gè)元素時(shí)，才能獲得所有返回值。這里先給出三個(gè)樣例函數(shù)，如：
    function foo0() end
    function foo1() return "a" end
    function foo2() return "a","b" end

    最后一個(gè)需要介紹的是Lua中unpack函數(shù)，該函數(shù)將接收數(shù)組作為參數(shù)，并從下標(biāo)1開(kāi)始返回該數(shù)組的所有元素。如：
    /> lua
    > print(unpack{10,20,30})
    10  20  30
    > a,b = unpack{10,20,30}
    > print(a,b)
    10  20
    > string.find(unpack{"hello","ll"})  --等同于string.find("hello","ll")
    在Lua中unpack函數(shù)是用C語(yǔ)言實(shí)現(xiàn)的。為了便于理解，下面給出在Lua中通過(guò)遞歸實(shí)現(xiàn)一樣的效果，如：

1 function unpack(t,i)
2     i = i or 1
3     if t[i] then
4         return t[i], unpack(t,i + 1)
5     end
6 end

    2. 變長(zhǎng)參數(shù)：
    Lua中的函數(shù)可以接受不同數(shù)量的實(shí)參，其聲明和使用方式如下：

1 function add(...)
2     local s = 0
3     for i, v in ipairs{...} do
4         s = s + v
5     end
6     return s
7 end
8 print(add(3,4,5,6,7))
9 --輸出結(jié)果為：25

    解釋一下，函數(shù)聲明中的(...)表示該函數(shù)可以接受不同數(shù)量的參數(shù)。當(dāng)這個(gè)函數(shù)被調(diào)用時(shí)，所有的參數(shù)都被匯聚在一起，函數(shù)中訪問(wèn)它時(shí)，仍需用3個(gè)點(diǎn)(...)。但不同的是，此時(shí)這3個(gè)點(diǎn)將作為表達(dá)式來(lái)使用，如{...}表示一個(gè)由所有變參構(gòu)成的數(shù)組。在含有變長(zhǎng)參數(shù)的函數(shù)中個(gè)，同樣可以帶有固定參數(shù)，但是固定參數(shù)一定要在變長(zhǎng)參數(shù)之前聲明，如：
    function test(arg1,arg2,...)
        ...
    end
    關(guān)于Lua的變長(zhǎng)參數(shù)最后需要說(shuō)明的是，由于變長(zhǎng)參數(shù)中可能包含nil值，因此再使用類似獲取table元素?cái)?shù)量(#)的方式獲取變參的數(shù)量就會(huì)出現(xiàn)問(wèn)題。如果要想始終獲得正確的參數(shù)數(shù)量，可以使用Lua提供的select函數(shù)，如：

1 for i = 1, select('#',...) do  --這里'#'值表示讓select返回變參的數(shù)量(其中包括nil)。
2     local arg = select(i, ...) --這里的i表示獲取第i個(gè)變參，1為第一個(gè)。
3     --do something
4 end

    3. 具名實(shí)參：
    在函數(shù)調(diào)用時(shí)，Lua的傳參規(guī)則和C語(yǔ)言相同，并不真正支持具名實(shí)參。但是我們可以通過(guò)table來(lái)模擬，比如：
    function rename(old,new)
        ...
    end
    這里我們可以讓上面的rename函數(shù)只接收一個(gè)參數(shù)，即table類型的參數(shù)，與此同時(shí)，該table對(duì)象將含有old和new兩個(gè)key。如：
    function rename(arg)
        local old = arg.old
        local new = arg.new
        ...
    end
    這種修改方式有些類似于JavaBean，即將多個(gè)參數(shù)合并為一個(gè)JavaBean。然而在使用時(shí)，Lua的table存在一個(gè)天然的優(yōu)勢(shì)，即如果函數(shù)只有一個(gè)參數(shù)且為string或table類型，在調(diào)用該函數(shù)時(shí)，可以不用加圓括號(hào)，如：
    rename {old = "oldfile.txt", new = "newfile.txt"}

二、深入函數(shù)：

    在Lua中函數(shù)和所有其它值一樣都是匿名的，即它們都沒(méi)有名稱。在使用時(shí)都是操作持有該函數(shù)的變量，如：
    a = { p = print }
    a.p("Hello World")
    b = print
    b("Hello World")
    在聲明Lua函數(shù)時(shí)，可以直接給出所謂的函數(shù)名，如：
    function foo(x) return 2 * x end
    我們同樣可以使用下面這種更為簡(jiǎn)化的方式聲明Lua中的函數(shù)，如：
    foo = function(x) return 2 * x end
    因此，我們可以將函數(shù)理解為由語(yǔ)句構(gòu)成的類型值，同時(shí)將這個(gè)值賦值給一個(gè)變量。由此我們可以將表達(dá)式"function(x) <body> end"視為一種函數(shù)的構(gòu)造式，就想table的{}一樣。我們將這種函數(shù)構(gòu)造式的結(jié)果稱為一個(gè)"匿名函數(shù)"。下面的示例顯示了匿名函數(shù)的方便性，它的使用方式有些類似于Java中的匿名類，如：
    table.sort(test_table,function(a,b) return (a.name > b.name) end)

    1. closure(閉合函數(shù))：
    若將一個(gè)函數(shù)寫(xiě)在另一個(gè)函數(shù)之內(nèi)，那么這個(gè)位于內(nèi)部的函數(shù)便可以訪問(wèn)外部函數(shù)中的局部變量，見(jiàn)如下示例：

 1 function newCounter() 
 2     local i = 0
 3     return function() --匿名函數(shù)
 4         i = i + 1
 5         return i
 6     end
 7 end
 8 c1 = newCounter()
 9 print("The return value of first call is " .. c1())
10 print("The return value of second call is " .. c1())
11 --輸出結(jié)果為：
12 --The return value of first call is 1
13 --The return value of second call is 2

    在上面的示例中，我們將newCounter()函數(shù)稱為閉包函數(shù)。其函數(shù)體內(nèi)的局部變量i被稱為"非局部變量"，和普通局部變量不同的是該變量被newCounter函數(shù)體內(nèi)的匿名函數(shù)訪問(wèn)并操作。再有就是在函數(shù)newCounter返回后，其值仍然被保留并可用于下一次計(jì)算。再看一下下面的調(diào)用方式。

 1 function newCounter() 
 2     local i = 0
 3     return function() --匿名函數(shù)
 4         i = i + 1
 5         return i
 6     end
 7 end
 8 c1 = newCounter()
 9 c2 = newCounter()
10 print("The return value of first call with c1 is " .. c1())
11 print("The return value of first call with c2 is " .. c2())
12 print("The return value of second call with c1 is " .. c1())
13 --輸出結(jié)果為：
14 --The return value of first call with c1 is 1
15 --The return value of first call with c2 is 1
16 --The return value of second call with c1 is 2

    由此可以推出，Lua每次在給新的閉包變量賦值時(shí)，都會(huì)讓不同的閉包變量擁有獨(dú)立的"非局部變量"。下面的示例將給出基于閉包的更為通用性的用法：

 1 do
 2     --這里將原有的文件打開(kāi)函數(shù)賦值給"私有變量"oldOpen，該變量在塊外無(wú)法訪問(wèn)。
 3     local oldOpen = io.open
 4     --新增一個(gè)匿名函數(shù)，用于判斷本次文件打開(kāi)操作的合法性。
 5     local access_OK = function(filename,mode) <檢查訪問(wèn)權(quán)限> end
 6     --將原有的io.open函數(shù)變量指向新的函數(shù)，同時(shí)在新函數(shù)中調(diào)用老函數(shù)以完成真正的打開(kāi)操作。
 7     io.open = function(filename,mode)
 8         if access_OK(filename,mode) then
 9             return oldOpen(filename,mode)
10         else
11             return nil,"Access denied"
12         end
13     end
14 end

    上面的這個(gè)例子有些類似于設(shè)計(jì)模式中裝飾者模式。

    2. 非全局函數(shù)：
    從上一小節(jié)中可以看出，Lua中的函數(shù)不僅可以直接賦值給全局變量，同時(shí)也可以賦值給其他類型的變量，如局部變量和table中的字段等。事實(shí)上，Lua庫(kù)中大多數(shù)table都帶有函數(shù)，如io.read、math.sin等。這種寫(xiě)法有些類似于C++中的結(jié)構(gòu)體。如：
    Lib = {}
    Lib.add = function(x,y) return x + y end
    Lib.sub = function(x,y) return x - y end
    或者是在table的構(gòu)造式中直接初始化，如：
    Lib = { add = function(x,y) return x + y end, 
               sub = function(x,y) return x - y end
             }
    除此之外，Lua還提供另外一種語(yǔ)法來(lái)定義此類函數(shù)，如：
    Lib = {}
    function Lib.add(x,y) return x + y end
    function Lib.sub(x,y) return x - y end
    對(duì)于Lua中的局部函數(shù)，其語(yǔ)義在理解上也是非常簡(jiǎn)單的。由于Lua中都是以程序塊作為執(zhí)行單元，因此程序塊內(nèi)的局部函數(shù)在程序塊外是無(wú)法訪問(wèn)的，如：

1 do
2     local f = function(x,y) return x + y end
3     --do something with f.
4     f(4,5)
5 end  

    對(duì)于這種局部函數(shù)，Lua還提供另外一種更為簡(jiǎn)潔的定義方式，如：
    local function f(x,y) return x + y end
    該寫(xiě)法等價(jià)于：
    local f
    f = function(x,y) return x + y end

    3. 正確的尾調(diào)用：
    在Lua中支持這樣一種函數(shù)調(diào)用的優(yōu)化，即“尾調(diào)用消除”。我們可以將這種函數(shù)調(diào)用方式視為goto語(yǔ)句，如：
    function f(x) return g(x) end
    由于g(x)函數(shù)是f(x)函數(shù)的最后一條語(yǔ)句，在函數(shù)g返回之后，f()函數(shù)將沒(méi)有任何指令需要被執(zhí)行，因此在函數(shù)g()返回時(shí)，可以直接返回到f()函數(shù)的調(diào)用點(diǎn)。由此可見(jiàn)，Lua解釋器一旦發(fā)現(xiàn)g()函數(shù)是f()函數(shù)的尾調(diào)用，那么在調(diào)用g()時(shí)將不會(huì)產(chǎn)生因函數(shù)調(diào)用而引起的棧開(kāi)銷(xiāo)。這里需要強(qiáng)調(diào)的是，尾調(diào)用函數(shù)一定是其調(diào)用函數(shù)的最后一條語(yǔ)句，否則Lua不會(huì)進(jìn)行優(yōu)化。然而事實(shí)上，我們?cè)诤芏嗫此剖俏舱{(diào)用的場(chǎng)景中，實(shí)際上并不是真正的尾調(diào)用，如：
    function f(x) g(x) end            --沒(méi)有return語(yǔ)句的明確提示
    function f(x) return g(x) + 1  --在g()函數(shù)返回之后仍需執(zhí)行一次加一的指令。
    function f(x) return x or g(x) --如果g()函數(shù)返回多個(gè)值，該操作會(huì)強(qiáng)制要求g()函數(shù)只返回一個(gè)值。
    function f(x) return (g(x))     --原因同上。
    在Lua中，只有"return <func>(<args>)"形式才是標(biāo)準(zhǔn)的尾調(diào)用，至于參數(shù)中(args)是否包含表達(dá)式，由于表達(dá)式的執(zhí)行是在函數(shù)調(diào)用之前完成的，因此不會(huì)影響該函數(shù)成為尾調(diào)用函數(shù)。

一、表達(dá)式：

    1. 算術(shù)操作符：
    Lua支持常規(guī)算術(shù)操作符有：二元的“+”、“-”、“*”、“/”、“^”(指數(shù))、“%”(取模)，一元的“-”(負(fù)號(hào))。所有這些操作符都可用于實(shí)數(shù)。然而需要特別說(shuō)明的是取模操作符(%)，Lua中對(duì)該操作符的定義為：
    a % b == a - floor(a / b) * b
    由此可以推演出x % 1的結(jié)果為x的小數(shù)部分，而x - x % 1的結(jié)果則為x的整數(shù)部分。類似的，x - x % 0.01則是x精確到小數(shù)點(diǎn)后兩位的結(jié)果。
    
    2. 關(guān)系操作符：
    Lua支持的關(guān)系操作符有：>、<、>=、<=、==、~=，所有這些操作符的結(jié)果均為true或false。
    操作符==用于相等性測(cè)試，操作符~=用于不等性測(cè)試。這兩個(gè)操作符可以應(yīng)用于任意兩個(gè)值。如果兩個(gè)值的類型不同，Lua就認(rèn)為他們不等。nil值與其自身相等。對(duì)于table、userdata和函數(shù)，Lua是通過(guò)引用進(jìn)行比較的。也就是說(shuō)，只有當(dāng)他們引用同一個(gè)對(duì)象時(shí)，才視為相等。如：

1 a = {}
2 a.x = 1
3 a.y = 0
4 b = {}
5 b.x = 1
6 b.y = 1
7 c = a

    其結(jié)果是a == c，但a ~= b。
    對(duì)于字符串的比較，Lua是按照字符次序比較的。
    
    3. 邏輯操作符：
    Lua支持的邏輯操作符有：and、or和not。與條件控制語(yǔ)句一樣，所有的邏輯操作符都將false和nil視為假，其他的結(jié)果均為真。和其他大多數(shù)語(yǔ)言一樣，Lua中的and和or都使用“短路原則”。在Lua中有一種慣用寫(xiě)法"x = x or v"，它等價(jià)于：if not x then x = v end。這里還有一種基于“短路原則”的慣用寫(xiě)法，如：
    max = (x > y) and x or y
    這等價(jià)于C語(yǔ)言中max = (x > y) ? x : y。由于x和y均為數(shù)值，因此它們的結(jié)果將始終為true。
    
    4. 字符串連接：
    前一篇Blog已經(jīng)提到了字符串連接操作符(..)，這里再給出一些簡(jiǎn)單的示例。
    /> lua
    > print("Hello " .. "World)
    Hello World
    > print(0 .. 1)  --即使連接操作符的操作數(shù)為數(shù)值類型，在執(zhí)行時(shí)Lua仍會(huì)將其自動(dòng)轉(zhuǎn)換為字符串。
    01

    5. table構(gòu)造器：
    構(gòu)造器用于構(gòu)建和初始化table的表達(dá)式。這是Lua特有的表達(dá)式，也是Lua中最有用、最通用的機(jī)制之一。其中最簡(jiǎn)單的構(gòu)造器是空構(gòu)造器{}，用于創(chuàng)建空table。我們通過(guò)構(gòu)造器還可以初始化數(shù)組，如：

 1 days = {"Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"}
 2 for i = 1,#days do
 3     print(days[i])
 4 end
 5 --輸出結(jié)果為
 6 --Sunday
 7 --Monday
 8 --Tuesday
 9 --Wednesday
10 --Thursday
11 --Friday
12 --Saturday

    從輸出結(jié)果可以看出，days在構(gòu)造后會(huì)將自動(dòng)初始化，其中days[1]被初始化為"Sunday"，days[2]為"Monday"，以此類推。
    Lua中還提供了另外一種特殊的語(yǔ)法用于初始化記錄風(fēng)格的table。如：a = { x = 10, y = 20 }，其等價(jià)于：a = {}; a.x = 10; a.y = 20
    在實(shí)際編程時(shí)我們也可以將這兩種初始化方式組合在一起使用，如：

polyline = {color = "blue", thickness = 2, npoints = 4, 
    {x = 0, y = 0},
    {x = 10, y = 0},
    {x = -10, y = 1},
    {x = 0, y = 1} }
print(polyline["color"]);
print(polyline[2].x)
print(polyline[4].y)
--輸出結(jié)果如下：
--blue
--10
--1

    除了以上兩種構(gòu)造初始化方式之外，Lua還提供另外一種更為通用的方式，如：

1 opnames = { ["+"] = "add", ["-"] = "sub", ["*"] = "mul", ["/"] = "div"}
2 print(opnames["+"])
3 i = 20; s = "-"
4 a = { [i + 0] = s, [i + 1] = s .. s, [i + 2] = s..s..s }
5 print(a[22])

    對(duì)于table的構(gòu)造器，還有兩個(gè)需要了解的語(yǔ)法規(guī)則，如：
    a = { [1] = "red", [2] = "green", [3] = "blue", }  
    這里需要注意最后一個(gè)元素的后面仍然可以保留逗號(hào)(,)，這一點(diǎn)類似于C語(yǔ)言中的枚舉。
    a = {x = 10, y = 45; "one", "two", "three" }
    可以看到上面的聲明中同時(shí)存在逗號(hào)(,)和分號(hào)(;)兩種元素分隔符，這種寫(xiě)法在Lua中是允許的。我們通常會(huì)將分號(hào)(;)用于分隔不同初始化類型的元素，如上例中分號(hào)之前的初始化方式為記錄初始化方式，而后面則是數(shù)組初始化方式。

二、語(yǔ)句：

    1. 賦值語(yǔ)句：
    Lua中的賦值語(yǔ)句和其它編程語(yǔ)言基本相同，唯一的差別是Lua支持“多重賦值”，如：a, b = 10, 2 * x，其等價(jià)于a = 10; b = 2 * x。然而需要說(shuō)明的是，Lua在賦值之前需要先計(jì)算等號(hào)右邊的表達(dá)式，在每一個(gè)表達(dá)式都得到結(jié)果之后再進(jìn)行賦值。因此，我們可以這樣寫(xiě)變量交互：x,y = y,x。如果等號(hào)右側(cè)的表達(dá)式數(shù)量少于左側(cè)變量的數(shù)量，Lua會(huì)將左側(cè)多出的變量的值置為nil，如果相反，Lua將忽略右側(cè)多出的表達(dá)式。

    2. 局部變量與塊：
    Lua中的局部變量定義語(yǔ)法為：local i = 1，其中l(wèi)ocal關(guān)鍵字表示該變量為局部變量。和全局變量不同的是，局部變量的作用范圍僅限于其所在的程序塊。Lua中的程序可以為控制結(jié)構(gòu)的執(zhí)行體、函數(shù)執(zhí)行體或者是一個(gè)程序塊，如：
    下面的x變量?jī)H在while循環(huán)內(nèi)有效。

1 while i <= x do
2     local x = i * 2
3     print(x)
4     i = i + 1
5 end

    如果是在交互模式下，當(dāng)執(zhí)行l(wèi)ocal x = 0之后，該變量x所在的程序即以結(jié)束，后面的Lua語(yǔ)句將被視為新的程序塊。如果想避免此類問(wèn)題，我們可以顯式的聲明程序塊，這樣即便是在交互模式下，局部變量仍然能保持其塊內(nèi)有效性，如：

1 do
2     local a2 = 2 * a
3     local d = (b ^ 2 - 4 * a) ^ (1 / 2)
4     x1 = (-b + d) / a2
5     x2 = (-b - d) / a2
6 end  --a2和d的作用域至此結(jié)束。

    和其它編程語(yǔ)言一樣，如果有可能盡量使用局部變量，以免造成全局環(huán)境的變量名污染。同時(shí)由于局部變量的有效期更短，這樣垃圾收集器可以及時(shí)對(duì)其進(jìn)行清理，從而得到更多的可用內(nèi)存。    

    3. 控制結(jié)構(gòu)：
    Lua中提供的控制語(yǔ)句和其它大多數(shù)開(kāi)發(fā)語(yǔ)言所提供的基本相同，因此這里僅僅是進(jìn)行簡(jiǎn)單的列舉。然后再給出差異部分的詳細(xì)介紹。如：
    1). if then else
    if a < 0 then 
        b = 0
    else
        b = 1
    end
    
    2). if elseif else then
    if a < 0 then 
        b = 0
    elseif a == 0 then
        b = 1
    else
        b = 2
    end
    
    3). while
    local i= 1
    while a[i] do
        print(a[i])
        i = i + 1
    end
    
    4). repeat
    repeat
        line = io.read()
    until line ~= "" --直到until的條件為真時(shí)結(jié)束。
    print(line)
    
    5). for
    for var = begin, end, step do --如果沒(méi)有step變量，begin的缺省步長(zhǎng)為1。
        i = i + 1
    end
    需要說(shuō)明的是，for循環(huán)開(kāi)始處的三個(gè)變量begin、end和step，如果它們使表達(dá)式的返回值，那么該表達(dá)式將僅執(zhí)行一次。再有就是不要在for的循環(huán)體內(nèi)修改變量var的值，否則會(huì)導(dǎo)致不可預(yù)知的結(jié)果。
    
    6). foreach
    for i, v in ipairs(a) do  --ipairs是Lua自帶的系統(tǒng)函數(shù)，返回遍歷數(shù)組的迭代器。
        print(v)
    end
    
    for k in pairs(t) do      --打印table t中的所有key。
        print(k)
    end
    見(jiàn)如下示例代碼：

 1 days = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }
 2 revDays = {}
 3 for k, v in ipairs(days) do
 4     revDays[v] = k
 5 end
 6 
 7 for k in pairs(revDays) do
 8     print(k .. " = " .. revDays[k])
 9 end
10 
11 --輸出結(jié)果為：
12 --Saturday = 7
13 --Tuesday = 3
14 --Wednesday = 4
15 --Friday = 6
16 --Sunday = 1
17 --Thursday = 5
18 --Monday = 2

    7). break
    和C語(yǔ)言中的break語(yǔ)義完全相同，即跳出最內(nèi)層循環(huán)。

一、基礎(chǔ)知識(shí)：

    1. 第一個(gè)程序和函數(shù)：
    在目前這個(gè)學(xué)習(xí)階段，運(yùn)行Lua程序最好的方式就是通過(guò)Lua自帶的解釋器程序，如：
    /> lua
    > print("Hello World")
    Hello World
    這樣我們就可以以交互性的方式輸入lua代碼，并立即得到執(zhí)行結(jié)果了。對(duì)于代碼塊較少的測(cè)試程序來(lái)說(shuō)，這種方式確實(shí)是非常方便的，然而對(duì)于相對(duì)復(fù)雜的程序而言，這種方式就不是很合適了。如果是這樣，我們可以將Lua代碼保存到一個(gè)獨(dú)立的Lua程序文件中，之后再通過(guò)Lua解釋器程序以命令行參數(shù)的形式執(zhí)行文件中的Lua代碼。如我們將下面的Lua代碼保存到test.lua的文件中：

 1 function fact(n)
 2     if n == 0 then
 3         return 1
 4     else
 5         return n * fact(n - 1)
 6     end
 7 end
 8 print("Enter a number:")
 9 a = io.read("*number")
10 print(fact(a))

    /> lua D:/test.lua
    Enter a number:
    4
    24

    2. 代碼規(guī)范：
    1). Lua的多條語(yǔ)句之間并不要求任何分隔符，如C語(yǔ)言的分號(hào)(;)，其中換行符也同樣不能起到語(yǔ)句分隔的作用。因此下面的寫(xiě)法均是合法的。如：

1 a = 1
2 b = a * 2
3     
4 a = 1;
5 b = a * 2;
6     
7 a = 1; b = a * 2;
8 a = 1  b = a * 2

    2). 通過(guò)dofile()方法引用其他Lua文件中的函數(shù)，如：

1 function fact(n)
2     if n == 0 then
3         return 1
4     else
5         return n * fact(n - 1)
6     end
7 end

    將上面的函數(shù)保存到test2.lua文件中。
    /> lua
    > dofile("d:/test2.lua")
    > print(fact(4))
    24
    3). 詞法規(guī)范。
    和大多數(shù)其它語(yǔ)言一樣，在聲明變量時(shí)，變量名可以由任意字母、數(shù)字和下劃線構(gòu)成，但是不能以數(shù)字開(kāi)頭。在Lua中還有一個(gè)特殊的規(guī)則，即以下劃線(_)開(kāi)頭，后面緊隨多個(gè)大寫(xiě)字母(_VERSION)，這些變量一般被Lua保留并用于特殊用途，因此我們?cè)诼暶髯兞繒r(shí)需要盡量避免這樣的聲明方式，以免給后期的維護(hù)帶來(lái)不必要的麻煩。
    Lua是大小寫(xiě)敏感的，因此對(duì)于一些Lua保留關(guān)鍵字的使用要特別小心，如and。但是And和AND則不是Lua的保留字。
    4). Lua中的注釋分為兩種，一種是單行注釋，如：
    --This is a single line comment.
    另外一種是多行注釋，如：
    --[[
    This is a multi-lines comment.
    --]]

    3. 全局變量：
    在Lua中全局變量不需要聲明，直接賦值即可。如果直接訪問(wèn)未初始化的全局變量，Lua也不會(huì)報(bào)錯(cuò)，直接返回nil。如果不想再使用該全局變量，可直接將其置為nil。如：
    /> lua
    > print(b)
    nil
    > b = 10
    > print(b)
    10
    > b = nil
    > print(b)
    nil
    
    4. 解釋器程序：
    命令行用法如下：
    lua [options] [lua-script [arguments] ]
    該工具的命令行選項(xiàng)主要有以下3個(gè)：
    -e: 可以直接執(zhí)行命令行中Lua代碼，如：lua -e "print(\"Hello World\")"
    -l: 加載該選項(xiàng)后的Lua庫(kù)文件，如：lua -l mylib -e "x = 10"，該命令在執(zhí)行之前先將mylib中的Lua代碼加載到內(nèi)存中，在后面的命令中就可以直接使用該文件中定義的Lua函數(shù)了。
    -i: 在執(zhí)行完指定的Lua程序文件之后，并不退出解釋器程序，而是直接進(jìn)入該程序的交互模式。    
    在解釋器程序的交互模式下，我們可以通過(guò)在表達(dá)式前加等號(hào)(=)標(biāo)識(shí)符的方式直接輸出表達(dá)式的執(zhí)行結(jié)果。通過(guò)該方式，我們可以將該程序用于計(jì)算器，如：
    /> lua
    > = 3 + 1 + 4
    8
    該小節(jié)最后需要介紹的是lua腳本的命令行參數(shù)訪問(wèn)規(guī)則。如：
    /> lua lua-script.lua a b c
    在該腳本的程序入口，lua解釋器會(huì)將所有命令行參數(shù)創(chuàng)建一個(gè)名為arg的table。其中腳本名(lua-script.lua)位于table索引的0位置上。它的第一個(gè)參數(shù)(a)則位于索引1，其它的參數(shù)以此類推。這種索引方式和C語(yǔ)言中讀取命令行參數(shù)的規(guī)則相同。但是不同的是，Lua提供了負(fù)數(shù)索引，用以訪問(wèn)腳本名稱之前的命令行參數(shù)，如：
    arg[-1] = lua
    arg[0] = lua-script.lua
    arg[1] = a
    arg[2] = b
    arg[3] = c

二、類型與值：

    Lua是一種動(dòng)態(tài)類型的語(yǔ)言。其語(yǔ)言本身沒(méi)有提供類型定義的語(yǔ)法，每個(gè)值都“攜帶”了它自身的類型信息。在Lua中有8中基礎(chǔ)類型，分別是：nil、boolean、number、string、userdata、function、thread和table。我們可以通過(guò)type函數(shù)獲得變量的類型信息，該類型信息將以字符串的形式返回。如：
    > print(type("hello world"))
    string
    > print(type(10.4))
    number
    > print(type(print))
    function
    > print(type(true))
    boolean
    > print(type(nil))
    nil
    > print(type(type(X)))
    string

    1. nil(空)：
    nil是一種類型，它只有一個(gè)值nil，它的主要功能是由于區(qū)別其他任何值。就像之前所說(shuō)的，一個(gè)全局變量在第一次賦值前的默認(rèn)值的默認(rèn)值就是nil，將nil賦予一個(gè)全局變量等同于刪除它。Lua將nil用于表示一種“無(wú)效值”的情況。
    
    2. boolean(布爾)：
    該類型有兩個(gè)可選值：false和true。在Lua中只有當(dāng)值是false和nil時(shí)才視為“假”，其它值均視為真，如數(shù)字零和空字符串，這一點(diǎn)和C語(yǔ)言是不同的。
    
    3. number(數(shù)字)：
    Lua中的number用于表示實(shí)數(shù)。Lua中沒(méi)有專門(mén)的類型表示整數(shù)。
    
    4. string(字符串)：
    Lua中的字符串通常表示“一個(gè)字符序列”。字符串類型的變量是不可變的，因此不能像C語(yǔ)言中那樣直接修改字符串的某一個(gè)字符，而是在修改的同時(shí)創(chuàng)建了新的字符串。如：

1 a = "one string"
2 b = string.gsub(a,"one","another")
3 print(a)
4 print(b)

    /> lua d:/test.lua    
    one string
    anotner string
    Lua支持和C語(yǔ)言類似的字符轉(zhuǎn)義序列，見(jiàn)下表：

    在Lua中還可以通過(guò)[[ all strings ]]的方式來(lái)禁用[[ ]]中轉(zhuǎn)義字符，如：
    page = [[ <html> <head> <title> An Html Page </title> </head> ]]
    如果兩個(gè)方括號(hào)中包含這樣的內(nèi)容：a = b[c[i]]，這樣將會(huì)導(dǎo)致Lua的誤解析，因此在這種情況下，我們可以將其改為[===[ 和 ]===]的形式，從而避免了誤解析的發(fā)生。
    Lua提供了運(yùn)行時(shí)的數(shù)字與字符串的自動(dòng)轉(zhuǎn)換。如：
    > print("10" + 1)
    11
    > print("10 + 1")
    10 + 1
    如果在實(shí)際編程中，不希望兩個(gè)數(shù)字字符串被自動(dòng)轉(zhuǎn)換，而是實(shí)現(xiàn)字符串之間的連接，可以通過(guò)" .. "操作符來(lái)完成。如：
    > print(10 .. 20)
    1020
    注意..和兩邊的數(shù)字之間必須留有空格，否則就會(huì)被Lua誤解析為小數(shù)點(diǎn)兒。
    盡管Lua提供了這種自動(dòng)轉(zhuǎn)換的功能，為了避免一些不可預(yù)測(cè)的行為發(fā)生，特別是因?yàn)長(zhǎng)ua版本升級(jí)而導(dǎo)致的行為不一致現(xiàn)象。鑒于此，還是應(yīng)該盡可能使用顯示的轉(zhuǎn)換，如字符串轉(zhuǎn)數(shù)字的函數(shù)tonumber()，或者是數(shù)字轉(zhuǎn)字符串的函數(shù)tostring()。對(duì)于前者，如果函數(shù)參數(shù)不能轉(zhuǎn)換為數(shù)字，該函數(shù)返回nil。如：

1 line = io.read()
2 n = tonumber(line)
3 if n == nil then
4     error(line .. " is not a valid number")
5 else
6     print(n * 2)
7 end

    關(guān)于Lua的字符串最后需要介紹的是"#"標(biāo)識(shí)符，該標(biāo)識(shí)符在字符串變量的前面將返回其后字符串的長(zhǎng)度，如：

1 a = "hello"
2 print(#a)

    /> lua d:/test.lua
    5
        
    5. table(表)：
    我們可以將Lua中table類型視為“關(guān)聯(lián)數(shù)組”，如C++標(biāo)準(zhǔn)庫(kù)中的map，差別是Lua中table的鍵(key)可以為任意類型(nil除外)，而map中的鍵只能為模參類型。此外，table沒(méi)有固定的大小，可以動(dòng)態(tài)的添加任意數(shù)量的元素到一個(gè)table中。table是Lua中最主要數(shù)據(jù)結(jié)構(gòu)，其功能非常強(qiáng)大，可用于實(shí)現(xiàn)數(shù)組、集合、記錄和隊(duì)列數(shù)據(jù)結(jié)構(gòu)。以下為table的變量聲明，以及關(guān)聯(lián)數(shù)據(jù)的初始化方式：

1 a = {}              -- 創(chuàng)建一個(gè)table對(duì)象，并將它的引用存儲(chǔ)到a
2 k = "x"
3 a[k] = 10           -- 創(chuàng)建了新條目，key = "x", value = 10
4 a[20] = "great"     -- 新條目，key = 20， value = "great"
5 print(a["x"])
6 k = 20
7 print(a[k])         -- 打印great
8 a["x"] = a["x"] + 1
9 print(a["x"])       -- 打印11

    所有的table都可以用不同類型的索引來(lái)訪問(wèn)value，當(dāng)需要容納新條目時(shí)，table會(huì)自動(dòng)增長(zhǎng)。

 1 a = {}
 2 for i = 1, 100 do
 3     a[i] = i * 2
 4 end
 5 print(a[9])
 6 a["x"] = 10
 7 print(a["x"])
 8 print(a["y"])      --table中的變量和全局變量一樣，沒(méi)有賦值之前均為nil。
 9 
10 --輸出結(jié)果為
11 --18
12 --10
13 --nil

    在Lua中還提供了另外一種方法用于訪問(wèn)table中的值，見(jiàn)如下示例：

1 a.x = 10      --等同于a["x"] = 10
2 print(a.x)    --等同于print(a["x"])
3 print(a.y)    --等同于print(a["y"])

    對(duì)于Lua來(lái)說(shuō)，這兩種方式是等價(jià)的。但是對(duì)于開(kāi)發(fā)者而言，點(diǎn)的寫(xiě)法隱式的將table表示為記錄，既C語(yǔ)言中的結(jié)構(gòu)體。而之前講述的字符串表示法則意味著任何字符串均可作為table的key。
    如果需要將table表示為傳統(tǒng)的數(shù)組，只需將整數(shù)作為table的key即可。如：

1 a = {}
2 for i = 1,10 do
3     a[i] = i * 2
4 end
5 
6 for i = 1,10 do
7     print(a[i])
8 end

    在Lua中，我通常習(xí)慣以1作為數(shù)組索引的起始值。而且還有不少內(nèi)部機(jī)制依賴于這個(gè)慣例。如：

1 a = {}
2 for i = 1,10 do
3     a[i] = i * 2
4 end
5 
6 for i = 1,#a do
7     print(a[i])
8 end

    由于數(shù)組實(shí)際上仍為一個(gè)table，所以對(duì)于數(shù)組大小的計(jì)算需要留意某些特殊的場(chǎng)景，如：
    a = {}
    a[1000] = 1
    在上面的示例中，數(shù)組a中索引值為1--999的元素的值均為nil。而Lua則將nil作為界定數(shù)據(jù)結(jié)尾的標(biāo)志。當(dāng)一個(gè)數(shù)組含有“空隙”時(shí)，即中間含有nil值，長(zhǎng)度操作符#會(huì)認(rèn)為這些nil元素就是結(jié)尾標(biāo)志。當(dāng)然這肯定不是我們想要的結(jié)果。因此對(duì)于這些含有“空隙”的數(shù)組，我們可以通過(guò)函數(shù)table.maxn()返回table的最大正數(shù)索引值。如：

1 a = {}
2 a[1000] = 1
3 print(table.maxn(a))    
4 
5 -- 輸出1000

    6. function(函數(shù))：
    在Lua中，函數(shù)可以存儲(chǔ)在變量中，可以通過(guò)參數(shù)傳遞其它函數(shù)，還可以作為其它函數(shù)的返回值。這種特性使語(yǔ)言具有了極大的靈活性。

    7. userdata(自定義類型)：
    由于userdata類型可以將任意C語(yǔ)言數(shù)據(jù)存儲(chǔ)到Lua變量中。在Lua中，這種類型沒(méi)有太多預(yù)定義的操作，只能進(jìn)行賦值和相等性測(cè)試。userdata用于表示一種由應(yīng)用程序或C語(yǔ)言庫(kù)所創(chuàng)建的新類型。

關(guān)于低耦合的消息傳遞，實(shí)現(xiàn)的方式有很多，哪種方法更好與具體的使用環(huán)境有關(guān)，本文使用試錯(cuò)的方法，逐步探索達(dá)成這一目的具體方式，并理解實(shí)現(xiàn)方式背后的原因。

面向?qū)ο蟮南到y(tǒng)當(dāng)中，不可避免的有大量的類間消息傳遞的需求：一個(gè)類需要通知另一個(gè)或幾個(gè)類做些什么。

這種類間消息傳遞，簡(jiǎn)單的說(shuō)，就是調(diào)用其他類的方法。

如下：

1void A::OnMessageXX()
2{
3         B::GetInstance()->DoSomething();
4
5}
6
7

在這里，類A需要通知類B做些事情。這種調(diào)用在所有的面向?qū)ο蟪绦蛑卸际菢O其常見(jiàn)的。

但是如果類A需要調(diào)用類B，就不可避免的產(chǎn)生了耦合性。雖然耦合性終歸是不可能完全避免的，但是在一定程度上降低耦合性是完全可能的。

（至于為什么在設(shè)計(jì)中應(yīng)該盡可能降低耦合性，不在本文的探討范圍之內(nèi)）

上面的例子，我們使用了Singleton的模式，從全局作用域中獲取了B的實(shí)例，并調(diào)用了B的相關(guān)方法。使用Singleton的一個(gè)缺點(diǎn)是，假若我們希望對(duì)類A編寫(xiě)測(cè)試代碼，我們需要做一些額外的解耦合工作。（關(guān)于編寫(xiě)測(cè)試與解耦合，可以參考Robert C. Martin Series 的Working Effectively with Legacy Code一書(shū)，該書(shū)的中譯版在這 ）

我們也可以通過(guò)將B參數(shù)化的方法降低A與B間的耦合程度，像下面這樣：

現(xiàn)在的寫(xiě)法要比之前的做法耦合性低，通過(guò)使用多態(tài)的方法，現(xiàn)在傳入函數(shù)的類B指針可能是另一個(gè)實(shí)現(xiàn)了B的相應(yīng)接口的派生類，A并不關(guān)心B接口背后的具體實(shí)現(xiàn)。

但是等等，你說(shuō)，現(xiàn)在對(duì)類B的耦合性雖然在A中被降低了，但是依舊存在于調(diào)用A::OnMessageXX的地方。在那里我們還是需要取得B的實(shí)例，然后傳遞給A。

沒(méi)錯(cuò)，是這樣。

通過(guò)參數(shù)化類A的方法，我們把類A與類B間的耦合轉(zhuǎn)移了一部分到A的調(diào)用者那里。實(shí)際上總的耦合并沒(méi)有消除，只是被分解了。但是程序設(shè)計(jì)中不可能完全不存在耦合，我們需要做的是”正確”，而不是”完美”。類A的耦合性降低了，使得我們?cè)谖磥?lái)需求變更的時(shí)候，類A有更大的可能性不需要被修改，并且對(duì)功能的擴(kuò)展更加友好，這就達(dá)成了我們的目標(biāo)了。

基于上述做法，如果我們?cè)谖磥?lái)擴(kuò)展是派生出一個(gè)B的子類，override相關(guān)的方法，那么類A的代碼基本是不需要修改的。

不過(guò)，問(wèn)題是，假若A::OnMessageXX中，并不僅僅需要對(duì)類B發(fā)出消息，還需要對(duì)一系列相關(guān)的類B1，B2，B3等等發(fā)出消息呢？

哦，或許我們可以這樣做：

void A::OnMessageXX(const std::list<B*>& lstBInstances)
{
         for (std::list<B*>::const_iterator itr = lstBInstances.begin();
                   itr != lstBInstances.end();
                   ++itr)
         {
                   (*itr)->DoSomething();

         }
}

是的，上面這是一種做法，有一系列B的對(duì)象需要被通知到，所以我們可以用一個(gè)列表把他們串起來(lái)，然后在循環(huán)中通知他們?nèi)ジ苫睢２贿^(guò)這樣做的前提是，這一系列B對(duì)象都是派生自一個(gè)公共基類B，有共通的接口；此外，我們需要在A的OnMessageXX被調(diào)用之前構(gòu)造一個(gè)需要接受通知的B對(duì)象列表。

當(dāng)A需要通知B，C，D等一系列沒(méi)有公共接口的對(duì)象的時(shí)候，上面的這種做法就無(wú)法處理了。

對(duì)于B、C、D等需要由A來(lái)調(diào)用的類來(lái)說(shuō)，它們需要在A通知它們的時(shí)候，做一些特定的事情。而又A則是在某些特定的時(shí)刻需要通知B、C、D。這樣，我們可以把問(wèn)題看成一個(gè)消息響應(yīng)機(jī)制。

B、C、D可以在A的某些事件上注冊(cè)一些回調(diào)函數(shù)，當(dāng)事件發(fā)生時(shí)，A確保注冊(cè)該事件的函數(shù)被調(diào)用到。

如下：

typedef void(callback*)();

class A {

public:

         enum EventIds {

         EVENT_MSG1,

         EVENT_MSG2,

};

void RegisterEvent(int nEventId, callback pfn);

private:

callback m_pfnCallback;

};

現(xiàn)在，B可以調(diào)用A::RegisterEvent注冊(cè)一個(gè)事件，并傳遞一個(gè)函數(shù)指針給A。

當(dāng)A中發(fā)生了注冊(cè)的事件時(shí)，這個(gè)函數(shù)指針會(huì)被回調(diào)到。

不過(guò)這種簡(jiǎn)單的做法適應(yīng)性很差：

1、  不能支持單個(gè)事件的多個(gè)callback (可能有很多類都需要注冊(cè)該事件，并在事件發(fā)生時(shí)依次被回調(diào))

2、  不能支持多個(gè)事件的同時(shí)存在

3、  回調(diào)函數(shù)沒(méi)有參數(shù)’

針對(duì)問(wèn)題1，2，我們可以使用一個(gè)事件映射解決問(wèn)題，做法如下：

typedef int EventId;

typedef void (callback*)();

typedef std::list<callback> CallbackList;

typedef std::map<EventId, CallbackList> CallbackMap;

現(xiàn)在這個(gè)數(shù)據(jù)結(jié)構(gòu)就能夠支持多個(gè)event同時(shí)存在，且每個(gè)event都可以支持多個(gè)回調(diào)函數(shù)了。

但是這種用法依舊很不方便，如果類B想要注冊(cè)A上的一個(gè)事件，他需要定義一個(gè) callback類型的函數(shù)，并把這個(gè)函數(shù)的地址傳遞給A。問(wèn)題是，往往我們希望類B的回調(diào)函數(shù)在被調(diào)用到的時(shí)候，對(duì)類B中的數(shù)據(jù)和狀態(tài)進(jìn)行修改，而一個(gè)單獨(dú)的函數(shù)，若想獲得/修改B中的狀態(tài)，則必須要與類B緊密耦合。（通過(guò)獲取全局對(duì)象，或者Singleton的方式）

這種緊密耦合引發(fā)我們的思考，能否在Callback中同時(shí)包含類B的指針與類B的成員函數(shù)。

答案是肯定的：泛型回調(diào) 就可以做到這一點(diǎn)。關(guān)于泛型回調(diào)(Generic callback)的信息，在Herb Sutter的Exceptional C++ Style 的35條中有詳細(xì)介紹。

一下比較簡(jiǎn)單的泛型回調(diào)的定義如下：

class callbackbase {

public:

virtual void operator()() const {};

virtual ~callbackbase() = 0 {};

};

template <class T>

class callback : public callbackbase {

public:

typedef void (T::*Func)();

callback(T& t, Func func) : object(t), f(func) {}     // 綁定到實(shí)際對(duì)象

void operator() () const { (object->*f)(); }              // 調(diào)用回調(diào)函數(shù)

private:

T* object;

Func f;

};

有了這種泛型回調(diào)類，我們就可以將類B的實(shí)例與B的成員回調(diào)函數(shù)綁定在一起注冊(cè)到容器當(dāng)中了，而不必再被如何在普通函數(shù)中修改B對(duì)象狀態(tài)的問(wèn)題所困擾了。不過(guò)回調(diào)函數(shù)的參數(shù)問(wèn)題依舊。如果想支持參數(shù)，我們不得不對(duì)每一種參數(shù)類型做一個(gè)不同的typedef，像上面定義的這樣 typedef void (T::*Func)();（如：typedef void (T::*Func)(int);）

一種解決方案是借助于Any（一種任意類型類）進(jìn)行參數(shù)傳遞。

但是還有更完善的解決方案，不需要id號(hào)，也不需要泛型回調(diào)，Ogre采用Listener的方式實(shí)現(xiàn)的類間消息傳遞不僅可以支持單個(gè)類B對(duì)類A中某個(gè)事件的單次/多次注冊(cè)，也可以支持類B、C、D對(duì)同一個(gè)事件的注冊(cè)。而且可以完美的解決參數(shù)傳遞問(wèn)題。

具體的方案如下：

 1class A {
 2public:
 3         class Listener 
 4        {
 5           public:
 6
 7                   virtual void OnMessageXX(int param1, float param2) = 0;
 8
 9                   virtual void OnMessageYY(int param1, const std::string& param2) = 0;
10
11        };
12
13void registerListener(Listener* obj) 
14{ 
15   m_lstListener.push_back(obj); 
16}
17
18void removeListener(Listener* obj)
19{
20         ListenerList::iterator itr = std::find(m_lstListener.begin(), m_lstListener.end(), obj); 
21
22         if (itr != m_lstListener.end())
23                   m_lstListener.erase(itr);
24}
25
26private:
27         typedef std::list<Listener*> ListenerList;
28
29         ListenerList m_lstListeners;
30};
31
32

有了以上定義，當(dāng)類A收到某個(gè)消息XX之后，只需遍歷m_lstListeners列表，調(diào)用所有列表成員的OnMessageXX即可。

而所有注冊(cè)A的消息的類，都必須從A::Listener派生一個(gè)類，在它感興趣的消息處理函數(shù)中做出相應(yīng)處理，而對(duì)不感興趣的消息，只需設(shè)為空函數(shù)即可。

一個(gè)簡(jiǎn)單的類B的定義如下：

class B {

public:

         friend class BListener;

         class BListener : public A::Listener {

         public:

                   BListener(B* pBInstance) : m_pBInstance(pBInstance) {}

                   virtual void OnMessageXX(int param1, float param2)

{ m_pBInstance->DoSomething(); }

                   virtual void OnMessageYY(int param1, const std::string& param2) {}

         private:

                   B* m_pBInstance;

};

explicit B(A* pAInstance) : m_pAInstance(pAInstance)

{

m_pListener(new BListener(this));

m_pAInstance->registerListener(m_pListener);

}

         ~B() { m_pAInstance->removeListener(m_pListener); delete m_pListener; }

void DoSomething();

private:

         BListener* m_pListener;

}

類B在創(chuàng)建自身實(shí)例時(shí)，接受一個(gè)A的指針（這是合理的，因?yàn)轭怋需要監(jiān)聽(tīng)類A的消息，理應(yīng)知道A的存在），并創(chuàng)建一個(gè)派生自A::Listener 的監(jiān)聽(tīng)者對(duì)象，并把自身的指針傳遞給該對(duì)象，以使得該監(jiān)聽(tīng)者改變類B的狀態(tài)，而后類B將創(chuàng)建好的監(jiān)聽(tīng)者對(duì)象加入到A的監(jiān)聽(tīng)者列表中。

在B進(jìn)行析構(gòu)的時(shí)候，需要從A中刪除自己注冊(cè)的監(jiān)聽(tīng)者。而后將該對(duì)象釋放。

這種做法的好處：

1、  類B（以及類C等）對(duì)類A實(shí)現(xiàn)了信息隱藏，類A不再關(guān)注任何需要監(jiān)聽(tīng)它自身消息的其他類，只需關(guān)注其自身的狀態(tài)。從而減低了類A與其他與之關(guān)聯(lián)的類之間的耦合。（類A不必再費(fèi)盡心機(jī)的去獲取B的指針，不管是通過(guò)全局變量，還是Singleton，還是參數(shù)，還是類成員變量，都不再需要了，A只關(guān)心在 Listener中定義好的一組接口即可）而且，如果有必要類B可以對(duì)同一個(gè)消息注冊(cè)多次，且可以對(duì)同一消息有不同的反應(yīng)（通過(guò)定義不同的 BListener實(shí)現(xiàn)達(dá)到這一目的），只需在B不再需要監(jiān)聽(tīng)相關(guān)消息時(shí)將所注冊(cè)過(guò)的對(duì)象注銷(xiāo)掉即可。

2、  由于1中所述，類A的實(shí)現(xiàn)無(wú)需關(guān)心類B的實(shí)現(xiàn)，因此類A的邏輯中不需要包含任何類B的方法調(diào)用，從而，類A的cpp文件中，無(wú)需包含類B的頭文件，（可能還包括類C，D等等，此處類B指代需要根據(jù)類A狀態(tài)而做出動(dòng)作的類）從而降低編譯時(shí)間，這是解耦合所帶來(lái)的附加好處。

3、  同樣是解耦合帶來(lái)的好處：因?yàn)闊o(wú)需關(guān)注類B等等其他類的實(shí)現(xiàn)，類A的代碼邏輯變得更加清晰，并且減少未來(lái)邏輯需求變更的改動(dòng)所需要付出的代價(jià)（邏輯變更可能需要更改接口，需要增加狀態(tài)判斷，無(wú)論是調(diào)試時(shí)間還是編譯時(shí)間都是不可忽視的代價(jià)）。

本文來(lái)自CSDN博客，轉(zhuǎn)載請(qǐng)標(biāo)明出處：http://blog.csdn.net/zougangx/archive/2009/07/30/4395775.aspx

 一. message 參數(shù)。
 message
 它能夠在編譯信息輸出窗口中輸出相應(yīng)的信息，這對(duì)于源代碼信息的控制是非常重要的。

 其使用方法為：  #pragma message("消息文本")

 當(dāng)編譯器遇到這條指令時(shí)就在編譯輸出窗口中將消息文本打印出來(lái)。
 當(dāng)我們?cè)诔绦蛑卸x了許多宏來(lái)控制源代碼版本的時(shí)候，我們自己有可能都會(huì)忘記有沒(méi)有正確的設(shè)置這些宏，此時(shí)我們可以用這條指令在編譯的時(shí)候就進(jìn)行檢查。假設(shè)我們希望判斷自己有沒(méi)有在源代碼的什么地方定義了_X86這個(gè)宏可以用下面的方法：
#ifdef _X86
#pragma message("_X86 macro activated!")
#endif
 當(dāng)我們定義了_X86這個(gè)宏以后，應(yīng)用程序在編譯時(shí)就會(huì)在編譯輸出窗口里顯示
 "_X86 macro activated!"
 這樣，我們就不會(huì)因?yàn)椴挥浀米约憾x的一些特定的宏而抓耳撓腮了。

 二. 另一個(gè)使用得比較多的#pragma參數(shù)是code_seg。
 格式如：
 #pragma code_seg( [ [ { push | pop}, ] [ identifier, ] ] [ "segment-name" [, "segment-class" ] )
 該指令用來(lái)指定函數(shù)在.obj文件中存放的節(jié),觀察OBJ文件可以使用VC自帶的dumpbin命令行程序,函數(shù)在.obj文件中默認(rèn)的存放節(jié)為.text節(jié)，如果code_seg沒(méi)有帶參數(shù)的話,則函數(shù)存放在.text節(jié)中。

 push (可選參數(shù)) 將一個(gè)記錄放到內(nèi)部編譯器的堆棧中,可選參數(shù)可以為一個(gè)標(biāo)識(shí)符或者節(jié)名
 pop(可選參數(shù)) 將一個(gè)記錄從堆棧頂端彈出,該記錄可以為一個(gè)標(biāo)識(shí)符或者節(jié)名
 identifier (可選參數(shù)) 當(dāng)使用push指令時(shí),為壓入堆棧的記錄指派的一個(gè)標(biāo)識(shí)符,當(dāng)該標(biāo)識(shí)符被刪除的時(shí)候和其相關(guān)的堆棧中的記錄將被彈出堆棧
   "segment-name" (可選參數(shù)) 表示函數(shù)存放的節(jié)名
 例如:
 //默認(rèn)情況下,函數(shù)被存放在.text節(jié)中
 void func1() {   // stored in .text
 }

 //將函數(shù)存放在.my_data1節(jié)中
 #pragma code_seg(".my_data1")
 void func2() {   // stored in my_data1
 }

 //r1為標(biāo)識(shí)符,將函數(shù)放入.my_data2節(jié)中
 #pragma code_seg(push, r1, ".my_data2")
 void func3() {   // stored in my_data2
 }

 int main() {
 }

 三. #pragma once (比較常用）
 這是一個(gè)比較常用的指令,只要在頭文件的最開(kāi)始加入這條指令就能夠保證頭文件被編譯一次

 四. #pragma hdrstop表示預(yù)編譯頭文件到此為止，后面的頭文件不進(jìn)行預(yù)編譯。
 BCB可以預(yù)編譯頭文件以加快鏈接的速度，但如果所有頭文件都進(jìn)行預(yù)編譯又可能占太多磁盤(pán)空間，所以使用這個(gè)選項(xiàng)排除一些頭文件。
 有時(shí)單元之間有依賴關(guān)系，比如單元A依賴單元B，所以單元B要先于單元A編譯。你可以用#pragma startup指定編譯優(yōu)先級(jí)，如果使用了#pragma package(smart_init) ，BCB就會(huì)根據(jù)優(yōu)先級(jí)的大小先后編譯。

 五. #pragma warning指令
 該指令允許有選擇性的修改編譯器的警告消息的行為
 指令格式如下:
 #pragma warning( warning-specifier : warning-number-list [; warning-specifier : warning-number-list...]
 #pragma warning( push[ ,n ] )
 #pragma warning( pop )

 主要用到的警告表示有如下幾個(gè):

 once:只顯示一次(警告/錯(cuò)誤等)消息
 default:重置編譯器的警告行為到默認(rèn)狀態(tài)
 1,2,3,4:四個(gè)警告級(jí)別
 disable:禁止指定的警告信息
 error:將指定的警告信息作為錯(cuò)誤報(bào)告

 如果大家對(duì)上面的解釋不是很理解,可以參考一下下面的例子及說(shuō)明

 #pragma warning( disable : 4507 34; once : 4385; error : 164 )
 等價(jià)于：
 #pragma warning(disable:4507 34)  // 不顯示4507和34號(hào)警告信息
 #pragma warning(once:4385)   // 4385號(hào)警告信息僅報(bào)告一次
 #pragma warning(error:164)   // 把164號(hào)警告信息作為一個(gè)錯(cuò)誤。
 同時(shí)這個(gè)pragma warning 也支持如下格式：
 #pragma warning( push [ ,n ] )
 #pragma warning( pop )
 這里n代表一個(gè)警告等級(jí)(1---4)。
 #pragma warning( push )保存所有警告信息的現(xiàn)有的警告狀態(tài)。
 #pragma warning( push, n)保存所有警告信息的現(xiàn)有的警告狀態(tài)，并且把全局警告等級(jí)設(shè)定為n。
 #pragma warning( pop )向棧中彈出最后一個(gè)警告信息，在入棧和出棧之間所作的一切改動(dòng)取消。例如：
 #pragma warning( push )
 #pragma warning( disable : 4705 )
 #pragma warning( disable : 4706 )
 #pragma warning( disable : 4707 )
 #pragma warning( pop )

 在這段代碼的最后，重新保存所有的警告信息(包括4705，4706和4707)

 在使用標(biāo)準(zhǔn)C++進(jìn)行編程的時(shí)候經(jīng)常會(huì)得到很多的警告信息,而這些警告信息都是不必要的提示,所以我們可以使用#pragma warning(disable:4786)來(lái)禁止該類型的警告在vc中使用ADO的時(shí)候也會(huì)得到不必要的警告信息,這個(gè)時(shí)候我們可以通過(guò)#pragma warning(disable:4146)來(lái)消除該類型的警告信息

 六. pragma comment(...)
 該指令的格式為：  #pragma comment( "comment-type" [, commentstring] )
 該指令將一個(gè)注釋記錄放入一個(gè)對(duì)象文件或可執(zhí)行文件中,comment-type(注釋類型):可以指定為五種預(yù)定義的標(biāo)識(shí)符的其中一種。
 五種預(yù)定義的標(biāo)識(shí)符為:

 1、compiler:將編譯器的版本號(hào)和名稱放入目標(biāo)文件中,本條注釋記錄將被編譯器忽略
如果你為該記錄類型提供了commentstring參數(shù),編譯器將會(huì)產(chǎn)生一個(gè)警告
例如:#pragma comment( compiler )

 2、exestr:將commentstring參數(shù)放入目標(biāo)文件中,在鏈接的時(shí)候這個(gè)字符串將被放入到可執(zhí)行文件中,當(dāng)操作系統(tǒng)加載可執(zhí)行文件的時(shí)候,該參數(shù)字符串不會(huì)被加載到內(nèi)存中.但是,該字符串可以被dumpbin之類的程序查找出并打印出來(lái),你可以用這個(gè)標(biāo)識(shí)符將版本號(hào)碼之類的信息嵌入到可執(zhí)行文件中!

 3、lib:這是一個(gè)非常常用的關(guān)鍵字,用來(lái)將一個(gè)庫(kù)文件鏈接到目標(biāo)文件中常用的lib關(guān)鍵字，可以幫我們連入一個(gè)庫(kù)文件。
 例如:
 #pragma comment(lib, "user32.lib")
 該指令用來(lái)將user32.lib庫(kù)文件加入到本工程中

 4、linker:將一個(gè)鏈接選項(xiàng)放入目標(biāo)文件中,你可以使用這個(gè)指令來(lái)代替由命令行傳入的或者在開(kāi)發(fā)環(huán)境中設(shè)置的鏈接選項(xiàng),你可以指定/include選項(xiàng)來(lái)強(qiáng)制包含某個(gè)對(duì)象,例如:
#pragma comment(linker, "/include:__mySymbol")
你可以在程序中設(shè)置下列鏈接選項(xiàng)
/DEFAULTLIB
/EXPORT
/INCLUDE
/MERGE
/SECTION

 這些選項(xiàng)在這里就不一一說(shuō)明了,詳細(xì)信息請(qǐng)看msdn!

 5、user:將一般的注釋信息放入目標(biāo)文件中commentstring參數(shù)包含注釋的文本信息,這個(gè)注釋記錄將被鏈接器忽略
 例如:
 #pragma comment( user, "Compiled on " __DATE__ " at " __TIME__ )

      int  WSAGetLastError(void );
#define h_errno   WSAGetLastError()

      u_long  htonl(u_long hostlong);
舉例：htonl(0)=0
htonl(80)= 1342177280

      u_long  ntohl(u_long netlong);
舉例：ntohl(0)=0
ntohl(1342177280)= 80

      u_short  htons(u_short hostshort);
舉例：htonl(0)=0
htonl(80)= 20480

      u_short  ntohs(u_short netshort);
舉例：ntohs(0)=0
ntohsl(20480)= 80

      unsigned long  inet_addr( const char FAR * cp );
舉例：inet_addr("192.1.8.84")=1409810880
inet_addr("127.0.0.1")= 16777343

      char FAR *  inet_ntoa( struct in_addr in );
舉例：char * ipaddr=NULL;
char addr[20];
in_addr inaddr;
inaddr. s_addr=16777343;
ipaddr= inet_ntoa(inaddr);
strcpy(addr,ipaddr); 

      int  getsockname(SOCKET s, struct sockaddr FAR * name, int FAR * namelen );
s為套接字
name為函數(shù)調(diào)用后獲得的地址值
namelen為緩沖區(qū)的大小。

      int  getpeername(SOCKET s, struct sockaddr FAR * name, int FAR * namelen );
s為套接字
name為函數(shù)調(diào)用后獲得的端地址值
namelen為緩沖區(qū)的大小。

      int  gethostname( char FAR * name, int namelen );
name是存放計(jì)算機(jī)名的緩沖區(qū)
namelen是緩沖區(qū)的大小
用法：
char szName[255];
memset(szName,0,255);
if(gethostname(szName,255)==SOCKET_ERROR)
{
//錯(cuò)誤處理
}
返回值為：szNmae="xiaojin"

      struct hostent FAR *  gethostbyname( const char FAR * name );
name為計(jì)算機(jī)名。
用法：
hostent * host;
char* ip;
host= gethostbyname("xiaojin");
if(host->h_addr_list[0])
{
struct in_addr addr;
memmove(&addr, host->h_addr_list[0]，4);
//獲得標(biāo)準(zhǔn)IP地址
ip=inet_ ntoa (addr);
}
返回值為：hostent->h_name="xiaojin"
hostent->h_addrtype=2    //AF_INET
hostent->length=4
ip="127.0.0.1"

• 阻塞模式：執(zhí)行I/O操作完成前會(huì)一直進(jìn)行等待，不會(huì)將控制權(quán)交給程序。套接字 默認(rèn)為阻塞模式。可以通過(guò)多線程技術(shù)進(jìn)行處理。
• 非阻塞模式：執(zhí)行I/O操作時(shí)，Winsock函數(shù)會(huì)返回并交出控制權(quán)。這種模式使用 起來(lái)比較復(fù)雜，因?yàn)楹瘮?shù)在沒(méi)有運(yùn)行完成就進(jìn)行返回，會(huì)不斷地返回 WSAEWOULDBLOCK錯(cuò)誤。但功能強(qiáng)大。

      int  select( int nfds, fd_set FAR * readfds, fd_set FAR * writefds, 
fd_set FAR *exceptfds, const struct timeval FAR * timeout );

#define FD_SETSIZE 64?
typedef struct fd_set {
u_int fd_count; /* how many are SET? */
SOCKET fd_array[FD_SETSIZE]; /* an array of SOCKETs */
} fd_set;      

struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* and microseconds */
};

1. nfds：沒(méi)有任何用處，主要用來(lái)進(jìn)行系統(tǒng)兼容用，一般設(shè)置為0。
   
2. readfds：等待可讀性檢查的套接字組。
   
3. writefds；等待可寫(xiě)性檢查的套接字組。
   
4. exceptfds：等待錯(cuò)誤檢查的套接字組。
   
5. timeout：超時(shí)時(shí)間。
   
6. 函數(shù)失敗的返回值：調(diào)用失敗返回SOCKET_ERROR,超時(shí)返回0。

fd_set fdread;
//FD_ZERO定義
// #define FD_ZERO(set) (((fd_set FAR *)(set))->fd_count=0)
FD_ZERO(&fdread);
FD_SET(s,&fdread)； //加入套接字，詳細(xì)定義請(qǐng)看winsock2.h
if(select(0,%fdread,NULL,NULL,NULL)>0
{
//成功
if(FD_ISSET(s,&fread) //是否存在fread中，詳細(xì)定義請(qǐng)看winsock2.h
{
//是可讀的
}
}

◆I/O操作函數(shù)：主要用于獲取與套接字相關(guān)的操作參數(shù)。

 int  ioctlsocket(SOCKET s, long cmd, u_long FAR * argp );     

//確定套接字自動(dòng)讀入的數(shù)據(jù)量
#define FIONREAD _IOR(''''f'''', 127, u_long) /* get # bytes to read */
//允許或禁止套接字的非阻塞模式，允許為非0，禁止為0
#define FIONBIO _IOW(''''f'''', 126, u_long) /* set/clear non-blocking i/o */
//確定是否所有帶外數(shù)據(jù)都已被讀入
#define SIOCATMARK _IOR(''''s'''', 7, u_long) /* at oob mark? */

      int  WSAAsyncSelect( SOCKET s, HWND hWnd, u_int wMsg, long lEvent);       

#define FD_READ_BIT 0
#define FD_READ (1 << FD_READ_BIT)
#define FD_WRITE_BIT 1
#define FD_WRITE (1 << FD_WRITE_BIT)
#define FD_OOB_BIT 2
#define FD_OOB (1 << FD_OOB_BIT)
#define FD_ACCEPT_BIT 3
#define FD_ACCEPT (1 << FD_ACCEPT_BIT)
#define FD_CONNECT_BIT 4
#define FD_CONNECT (1 << FD_CONNECT_BIT)
#define FD_CLOSE_BIT 5
#define FD_CLOSE (1 << FD_CLOSE_BIT)

int nResult= WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE)；
if(nResult==SOCKET_ERROR)
{
//錯(cuò)誤處理
}

      int nResult= WSAAsyncSelect(s,hWnd,0，0)；

#define WSAEVENT HANDLE
#define LPWSAEVENT LPHANDLE
WSAEVENT WSACreateEvent( void );

      int  WSAEventSelect( SOCKET s,WSAEVENT hEventObject,long lNetworkEvents );  

BOOL WSAResetEvent( WSAEVENT hEvent );

Hevent為事件對(duì)象

成功返回TRUE，失敗返回FALSE。

d、等待網(wǎng)絡(luò)事件來(lái)觸發(fā)事件句柄的工作狀態(tài)：

DWORD WSAWaitForMultipleEvents( DWORD cEvents,
const WSAEVENT FAR * lphEvents, BOOL fWaitAll,
DWORD dwTimeout, BOOL fAlertable );

lpEvent為事件句柄數(shù)組的指針
cEvent為為事件句柄的數(shù)目，其最大值為WSA_MAXIMUM_WAIT_EVENTS 
fWaitAll指定等待類型：TRUE：當(dāng)lphEvent數(shù)組重所有事件對(duì)象同時(shí)有信號(hào)時(shí)返回；
FALSE：任一事件有信號(hào)就返回。
dwTimeout為等待超時(shí)（毫秒）
fAlertable為指定函數(shù)返回時(shí)是否執(zhí)行完成例程

對(duì)事件數(shù)組中的事件進(jìn)行引用時(shí)，應(yīng)該用WSAWaitForMultipleEvents的返回值，減去
預(yù)聲明值WSA_WAIT_EVENT_0，得到具體的引用值。例如：

nIndex=WSAWaitForMultipleEvents(…);
MyEvent=EventArray[Index- WSA_WAIT_EVENT_0];

e、判斷網(wǎng)絡(luò)事件類型：

int WSAEnumNetworkEvents( SOCKET s,
WSAEVENT hEventObject, LPWSANETWORKEVENTS lpNetworkEvents );

s為套接字
hEventObject為需要重設(shè)的事件對(duì)象
lpNetworkEvents為記錄網(wǎng)絡(luò)事件和錯(cuò)誤代碼，其結(jié)構(gòu)定義如下：

typedef struct _WSANETWORKEVENTS {
long lNetworkEvents;
int iErrorCode[FD_MAX_EVENTS];
} WSANETWORKEVENTS, FAR * LPWSANETWORKEVENTS;

f、關(guān)閉事件對(duì)象句柄：

BOOL WSACloseEvent(WSAEVENT hEvent);

調(diào)用成功返回TRUE，否則返回FALSE。