缺少閉包編程語言

Ⅰ (離散數學)輸入一個關系矩陣,用C語言編程求出它的自反閉包,對稱閉包和傳遞閉包

我用面向對象寫的 自己改一下

#include<iostream.h>
template<class T>
void Warshall( T *a , int m , int n )
{
int i = 0,j = 0;
for( i = 0 ; i < n ; i++ )
{
for( j = 0 ; j < m ; j++ )
{
if( a[j][i] == 1 )
{
int k = 0;
for( int x = 0 ; x < n ; x++ )
{
a[j][k] = a[j][k] || a[i][k];
k++;
}
}
}

}
for( i = 0 ; i < m ; i++ )
{
for( j = 0 ; j < n ; j++ )
{
cout << a[i][j] << '\t';
}
cout<<endl;
}
}
void main()
{
int ai[4][4] = { {0,1,0,0} , {1,0,1,0} , {0,0,0,1} , {0,0,0,0} };
Warshall(ai,4,4);
}

Ⅱ java builder模式為什麼很少人用

我認為Java語言的10大問題是：
1、缺少閉包（closure）：我想這個不需要解釋了。函數式編程已經存在幾十年了，但最近幾年，它們獲得了越來越多的關注，最主要的原因，是它可以自然地編寫並行程序。我部分的同意Joshua Bloch強調在Java中引入閉包的問題需要再想一想（BGGA提議的方式真的很糟），至少閉包的缺失，使得在Java中做任何真正的函數式編程都是不可能的。
2、缺少一等函數：這個問題與前一個有些關聯，但我認為它更糟糕。在Java里，要達到類似效果的唯一方式，是使用著名的、醜陋悲慘的單方法匿名內部類，但這看上去的確是一個拙劣的方法。甚至在C#中，也通過代理機制，提供了一個更好的實現。
3、原生類型（Primitive types）：如果在Java中一切皆對象，那是多麼完美啊，但他們偏偏不這樣設計。因而，這一點導致了一些問題，比如，不能把一個int放到集合（Collection）里，這個在Java5中通過自動裝箱特性得到了解決（下面會提到）。它也造成了傳值與傳引用上的困擾，原生類型數據是通過值傳給方法的（復制一份拷貝，然後傳給函數），而真正的對象是通過傳遞（譯註：其實是復制對象地址再傳遞，因此應該也是傳值方式，只是由於函數內部可通過這個對象地址訪問對象，因此效果上類似傳引用）。
4、自動裝箱（Autoboxing）和自動拆箱（autounboxing）：這個特性是為了解決因原生類型的存在所導致的問題，在Java5引入的。它允許靜默地轉換原生類型到相應的對象，但這常常導致其它的問題。比如Integer可以為null，但int不能，因此這時JVM只能拋出一個難以調試的空指針異常（NullPointerException）。此外，它還可能導致其它奇怪的行為，就像下面的例子，我們就很難理解，變數test為什麼是false：
Intger a = new Integer(1024);
Intger b = new Integer(1024);
boolean test = a b || a == b || a > b;
5、缺少范型具類化：范型是Java5引入的一個很酷的特徵，但是為了保持與舊版本Java的兼容性，導致缺失某些重要的特性，尤其是不能在運行時反省范型的類型。例如，你有一個方法，接受List參數，如果傳進來一個List，你卻不能知道運行里該范型的確切類型。同理，你也不能創建范型數組。這意味著，盡管下面的代碼看起來很自然，但卻不編譯不了：
List[] listsOfStrings = new List[3];
6、不可避免的范型警告：你有發現過自己陷入不可能去掉的關於范型的警告么？如果你像我一樣大量使用范型，我打賭你碰到過。事實上，是這個問題的規模化症狀，讓他們認為需要引入一個特定的註解(@SuppressWarnings("unchecked"))來處理這種情況，我覺得，范型應該可能被設計的更好。
7、不能傳void給方法調用：我得承認，這種給方法傳遞void的需求，乍一看有些怪異。我喜歡DSL，當我實現自己的DSL庫（lambdaj）的一個特定特性時，我不得不需要一個方法聲明成這樣的簽名：void doSomething(Object parameter)，這里為這個方法傳進來的參數parameter，是另一個方法調用的結果，它唯一的目的，是注冊調用（的對象）自身，以可以在以後執行它。讓我吃驚的是，即使println方法返回void，看上去也並沒有一個好理由，不允許我把代碼寫成這樣，：
doSomething(System.out.println("test"));
8、沒有原生的代理機制：代理是一種非常有效和應用廣泛的模式，但Java提供的代理機制，只針對介面，而不是具體類。這是為什麼象cblib這樣提供這種機制的庫，被如此多的主流框架，如Spring和Hibernate，採用的原因。此外，由於cglib通過運行時創建被代理類的子類來實現的，因此這些種方式有一個眾所周知的限制——不能代理final類，比如String。
9、差勁的Switch...case語句：Java規定，switch...case只能選擇int和enum（Java5開始）。這一點如果跟更現代的語言如Scala相比，看起來簡直太弱了。
10、受檢查異常（Checked exception）：類似原生類型，受檢查異常也已經成為Java的一個罪孽之源。它迫使程序員必須做下面兩件極其糟糕討厭的事情中的一個：讓你的代碼里充斥大量的、糟糕難讀的、容易出錯的try...catch語句，而這樣做的最大意義，只是將捕獲的異常，包裝成運行時異常，然後再重新拋出；或者是讓大量的拋出聲明子句污染你的API，讓介面缺少靈活性和可擴展性。
真正的問題是，這里我提到的這幾大主要問題，唯一的解決辦法，是要做一個痛苦的決擇，定義一套新的語言規范，放下當前版本的向後兼容性。我猜他們永遠也不會這么做，雖然我相信，如果編寫一個能夠自動轉換舊Java源碼的程序，讓它們與假設的新版本兼容，並不是很困難。最後，這就是我決定開始尋找一個更好的JVM兼容語言的原因。

Ⅲ 如何評價 Racket 這門編程語言

Racket的誕生與發展

簡單介紹一下Racket的發展，詳見知乎的一個關於Racket的問題回答：
1958年，人工智慧之父John McCarthy 發明了一種以 Lambda 演算為基礎的符號處理語言，1960年 McCarthy 發表著名論文Recursive Functions of Symbolic Expressions and Their Computation by Machine, 從此這種語言被命名為 LSIP (List Processor），其語法被命名為：符號表達式(S-Expression)。LISP構建在7個函數[atom car cdr cond cons eq quote]和2個特型[lambda label]之上。

Lisp誕生之初是為了純粹的科學研究，代碼執行像數學公式一樣，以人的大腦來演算。直到麥卡錫的學生斯蒂芬·羅素將eval函數在IBM 704機器上實現後，才開啟了Lisp作為一種計算機語言的歷史。1962年，第一個完整的Lisp編譯器在MIT誕生，從此之後Lisp以MIT為中心向全世界傳播。之後十多年，出現了各種Lisp方言。

1975年，Scheme誕生。Scheme同樣誕生與MIT，它的設計哲學是最小極簡主義，它只提供必須的少數幾個原語，所有其他的實用功能都由庫來實現。在極簡主義的設計思想下，Scheme趨於極致的優雅，並作為計算機教學語言在教育界廣泛使用。

1984年，Common Lisp誕生。在二十世紀七八十年代，由於Lisp方言過多，社區分裂，不利於lisp整體的發展。從1981年開始，在一個Lisp黑客組織的運作下，經過三年的努力整合後，於1984年推出了Common Lisp。由於Scheme的設計理念和其他Lisp版本不同，所以盡管Common Lisp借鑒了Scheme的一些特點，但沒有把Scheme整合進來。此後Lisp僅剩下兩支方言： Common Lisp 和 Scheme。

從二十世紀九十年代開始，由於C++、Java、C#的興起，Lisp逐漸沒落。直到2005年後，隨著科學計算的升溫，動態語言JavaScript、python、Ruby的流行，Lisp又漸漸的回到人們的視線。不過在Lisp的傳統陣地教育界，Python作為強有力的挑戰者對Scheme發起沖鋒；在2008年，MIT放棄了使用Scheme作為教學語言的SICP（計算機程序的構造和解釋）課程，而啟用Python進行基礎教學。同時美國東北大學另立爐灶，其主導的科學計算系統PLT Scheme開始迅猛發展；2010年，PLT Scheme改名為Racket。近幾年，The Racket Language連續成為年度最活躍語言網站，並駕齊驅的還有haskell網站。

符號表達式 S-Expression

首先說一下S表達式：S-表達式的基本元素是list與atom。list由括弧包圍，可包涵任何數量的由空格所分隔的元素，原子是其它內容。其使用前綴表示法，在Lisp中既用作代碼，也用作數據。如：1+2*3 寫成前綴表達式就是(+ 1 (* 2 3)) 。

優點：容易parse，簡單純粹，不用考慮什麼優先順序等，也是實現代碼即數據的前提；

缺點：可讀性不是很強；

高階函數

高階函數至少滿足下列一個條件：

接受一個或多個函數作為輸入；

輸出一個函數；

微積分中的導數就是一個例子，映射一個函數到另一個函數。在無類型 lambda 演算中，所有函數都是高階的。在函數式編程中，返回另一個函數的高階函數被稱為Curry化的函數。Curry化即把接受多個參數的函數變換成接受一個單一參數（最初函數的第一個參數）的函數，並且返回接受餘下的參數而且返回結果的新函數的技術。如 f(x,y)=x+y, 如果給定了 y=1，則就得到了 g(x)=x+1 這個函數。

Lambda 表達式

Racket中實用Lambda表達式來定義匿名函數，《如何設計程序》書中給出的使用原則是：如果某個非遞歸函數只需要當參數使用一次，實用Lambda表達式。如果想用Lambda表達式來表達遞歸，就需要引入Y組合子，Y 就是這樣一個操作符，它作用於任何一個 (接受一個函數作為參數的) 函數 F，就會返回一個函數 X。再把 F 作用於這個函數 X，還是得到 X。所以 X 被叫做 F 的不動點(fixed point)，即 (Y F) = (F (Y F)) 。

惰性求值

惰性求值(Lazy Evaluation)，說白了就是某些中間結果不需要被求出來，求出來反而不利於後面的計算也浪費了時間。參見：惰性求值與惰性編程。
惰性求值是一個計算機編程中的一個概念，它的目的是要最小化計算機要做的工作。惰性計算的最重要的好處是它可以構造一個無限的數據類型。使用惰性求值的時候，表達式不在它被綁定到變數之後就立即求值，而是在該值被取用的時候求值。語句如 x:=expression; (把一個表達式的結果賦值給一個變數)明顯的調用這個表達式並把計算並把結果放置到 x 中，但是先不管實際在 x 中的是什麼，直到通過後面的表達式中到 x 的引用而有了對它的值的需求的時候，而後面表達式自身的求值也可以被延遲，最終為了生成讓外界看到的某個符號而計算這個快速增長的依賴樹。

閉包

閉包在計算機科學中，閉包（Closure）是詞法閉包（Lexical Closure）的簡稱，是引用了自由變數的函數。自由變數是在表達式中用於表示一個位置或一些位置的符號，比如 f(x,y) 對 x 求偏導時，y就是自由變數。這個被引用的自由變數將和這個函數一同存在，即使已經離開了創造它的環境也不例外。在函數中(嵌套)定義另一個函數時，如果內部的函數引用了外部的函數的變數，則可能產生閉包。運行時，一旦外部的 函數被執行，一個閉包就形成了，閉包中包含了內部函數的代碼，以及所需外部函數中的變數的引用。其中所引用的變數稱作上值(upvalue)。網上有很多將JavaScript閉包的文章，如果你對LISP有系統的了解，那麼這個概念自然會很清楚了。

快排的Racket實現

#langracket
(define(quick-sortarray)
(cond
[(empty?array)empty];快排的思想是分治+遞歸
[else(append
(quick-sort(filter(lambda(x)(<x(firstarray)))array));這里的array就是閉包
(filter(lambda(x)(=x(firstarray)))array)
(quick-sort(filter(lambda(x)(>x(firstarray)))array)))]))
(quick-sort'(132534509824))
;;運行結果'(012334455982)

通過這個例子，就可以感受到基於lambda運算元的 Racket 語言強大的表達能力了，高階函數、lambda表達式和閉包的使用是Racket所描述的快排十分的精煉，這和 基於馮諾依曼模型C語言是迥然不容的思維模式。後面，隨著Racket 學習的進一步深入，嘗試寫一下解釋器

Ⅳ 二元關系的閉包運算編程 能用c語言編的最好～

httpPost.setEntity(new UrlEncodedFormEntity(nvps, encoding));

System.out.println("請求地址："+url);
System.out.println("請求參數："+nvps.toString());

Ⅳ 簡單的閉包問題

概念

閉包，在《javascripts高級程序設計》裡面是這樣介紹的:閉包是指有權訪問另一個作用域中的變數的函數。額。。這句話我以前看過很多遍，但依然不是很懂，只知道它是跟作用域有關。現在我知道了，如果這句話換成：但凡是內部的函數被保存到了外部，必定生成閉包。這樣就容易理解多了不是。
我們以下面的這個代碼塊為例：

例子解釋

function a() {const num = 100;function b () {num++;console.log(num);}return b;}const demo = a();demo();demo();

我們先執行上述代碼，看看結果是什麼：

a執行完，返回了b,此時的b只是聲明，但還沒調用，所以沒有形成自己的AO,但作用域鏈和 a doing 時是一樣的，所以雖然 a() 的作用域被銷毀了，但是相同的一份卻被b保存到了外面。這也就是內部函數被保存到了外面形成閉包的本質。這樣也不難理解為什麼上述代碼列印出來的值是那樣的了：

• 執行第一個demo()時，也即是執行 b(),由於b保存了a的作用域鏈，所以也可以訪問到 num ,執行 b() 後，加一；

• 那為什麼第二次執行 demo(),列印出的值還是有自增了呢？這是因為操作的都是保存在 b 里的 num ,雖然每次調用 demo() 都會形成新的作用域鏈，但是num，卻是每次從上一次的作用域鏈直接 到當前作用域鏈中的。

這樣形成的閉包雖然可以使外部可以訪問到內部的函數，但是導致了原有的作用域鏈不釋放，會造成內存泄漏。（內存泄漏的意思就是佔用內存，可用內存資源變少了）。所以如果不是特殊需要，應盡量防止這種情況發生。

並且，作用域鏈的配置機制引出了一個值得注意的副作用：即閉包只取得包含函數中任何變數最後一個值，比如下面這個例子：

• function createFunctions() {var result = [];for(let i = 0; i< 10; i++) {result[i] = function() {console.log(i);}}return result;}var myArr = createFunctions();for(var j = 0; j < 10; j++) {myArr[j]();}



這個函數會返回一個函數數組，表面上看，似乎每個函數都應該有自己的索引值，即會返回：0，1，2...9;但實際上，每個函數都會返回10;這是因為在createFunctions()執行時，for循環跳出的條件是i=10；所以函數返回後，i的值是10 ；而每個result的作用域鏈中都保存這createFunctions()的AO,所以他們引用的都是createFunctions()的i值，所以每個函數內部i的值都是10；
這樣，我們可以創建一個立即執行函數強制讓閉包的行為符合預期：

• function createFunctions() {var result = [];for(var i = 0; i < 10; i++) {(function(j) {result[i] = function() {document.write(j + " ");}}(i));}return result;}var myArr = createFunctions();for(var j = 0; j < 10; j++) {myArr[j]();}



典型應用

下面看看幾個用到閉包的典型例子：

• 實現共有變數

  如累加器:調用多少次，累加多少次，用閉包更加模塊化

• function add() {var count = 0;function demo() {count++;console.log(count);}return demo;}var counter = add();counter();//1counter();//2counter();//3



• 實現緩存

如eater: eat和push保存的都是eater的AO;,所以eat中food改變後。實際上是eater變了，所以也會影響push;

• function eater() {var food = '';var obj = {eat: function() {console.log('eating' + food);food = '';},push: function(myFood) {food = myFood;}}return obj;// 相當於返回裡面的eat和push操作food;}var eater1 = eater();eater1.push('banana');eater1.eat();

Ⅵ java開發的缺點

很難說哪一個比較好!!!
以java開發來說的話需要會的方面要很全面，基本功要很扎實!!!
而已android來說需要的是靈活的思維和創新，這兩點有了，就算你做的程式很簡單也很多人會用
像YO就是一的典型例子!!

Ⅶ 閉包的Lua中

當一個函數內部嵌套另一個函數定義時，內部的函數體可以訪問外部的函數的局部變數，這種特徵在lua中我們稱作詞法定界。雖然這看起來很清楚，事實並非如此，詞法定界加上第一類函數在編程語言里是一個功能強大的概念，很少語言提供這種支持。
下面看一個簡單的例子，假定有一個學生姓名的列表和一個學生名和成績對應的表；想根據學生的成績從高到低對學生進行排序， names = {Peter,Paul,Mary}
grades = {Mary = 10,Paul = 7,Peter = 8}
table.sort(names,function (n1,n2）
return grades[n1] > grades[n2] -- compare the grades
end) 假定創建一個函數實現此功能：
function sortbygrade (names,grades)
table.sort(names,function (n1,n2）
return grades[n1] > grades[n2] --compare the grades
end) 例子中包含在sortbygrade函數內部的sort中的匿名函數可以訪問sortbygrade的參數grades，在匿名函數內部grades不是全局變數也不是局部變數，我們稱作外部的局部變數（external local variable）或者upvalue。（upvalue意思有些誤導，然而在Lua中他的存在有歷史的根源，還有他比起external local variable簡短）。
看下面的代碼：
function newCounter()
local i = 0
return function() -- anonymous function
i = i + 1
return i
end
end
c1 = newCounter()
print(c1()) --> 1
print(c1()) --> 2
匿名函數使用upvalue i保存他的計數，當我們調用匿名函數的時候i已經超出了作用范圍，因為創建i的函數newCounter已經返回了。然而Lua用閉包的思想正確處理了這種情況。簡單的說，閉包是一個函數以及它的upvalues。如果我們再次調用newCounter，將創建一個新的局部變數i，因此我們得到了一個作用在新的變數i上的新閉包。
c2 = newCounter()
print(c2()) --> 1
print(c1()) --> 3
print(c2()) --> 2
c1、c2是建立在同一個函數上，但作用在同一個局部變數的不同實例上的兩個不同的閉包。
技術上來講，閉包指值而不是指函數，函數僅僅是閉包的一個原型聲明；盡管如此，在不會導致混淆的情況下我們繼續使用術語函數代指閉包。
閉包在上下文環境中提供很有用的功能，如前面我們見到的可以作為高級函數（sort）的參數；作為函數嵌套的函數（newCounter）。這一機制使得我們可以在Lua的函數世界裡組合出奇幻的編程技術。閉包也可用在回調函數中，比如在GUI環境中你需要創建一系列button，但用戶按下button時回調函數被調用，可能不同的按鈕被按下時需要處理的任務有點區別。具體來講，一個十進制計算器需要10個相似的按鈕，每個按鈕對應一個數字，可以使用下面的函數創建他們：
function digitButton (digit)
return Button{ label = digit,
action = function ()
add_to_display(digit)
end
}
end
這個例子中我們假定Button是一個用來創建新按鈕的工具，label是按鈕的標簽，action是按鈕被按下時調用的回調函數。（實際上是一個閉包，因為他訪問upvalue digit）。digitButton完成任務返回後，局部變數digit超出范圍，回調函數仍然可以被調用並且可以訪問局部變數digit。
閉包在完全不同的上下文中也是很有用途的。因為函數被存儲在普通的變數內我們可以很方便的重定義或者預定義函數。通常當你需要原始函數有一個新的實現時可以重定義函數。例如你可以重定義sin使其接受一個度數而不是弧度作為參數：
oldSin = math.sin
math.sin = function (x)
return oldSin(x*math.pi/180）
end
更清楚的方式：
do
local oldSin = math.sin
local k = math.pi/180
math.sin = function (x)
return oldSin(x*k)
end
end
這樣我們把原始版本放在一個局部變數內，訪問sin的唯一方式是通過新版本的函數。
利用同樣的特徵我們可以創建一個安全的環境（也稱作沙箱，和java里的沙箱一樣），當我們運行一段不信任的代碼（比如我們運行網路伺服器上獲取的代碼）時安全的環境是需要的，比如我們可以使用閉包重定義io庫的open函數來限製程序打開的文件。
do
local oldOpen = io.open
io.open = function (filename,mode)
if access_OK(filename,mode) then
return oldOpen(filename,mode)
else
return nil,access denied
end
end Scheme中的閉包
其他編程的語言主要採用的是閉包的第二種意義（一個與閉包毫不相乾的概念）：閉包也算一種為表示帶有自由變數的過程而用的實現技術。但Scheme的術語「閉包」來自抽象代數。在抽象代數里，一集元素稱為在某個運算（操作）之下封閉，如果將該運算應用於這一集合中的元素，產生出的仍然是該集合里的元素。
用Scheme的序對舉例，為了實現數據抽象，Scheme提供了一種稱為序對的復合結構。這種結構可以通過基本過程cons構造出來。過程cons取兩個參數，返回一個包含這兩個參數作為其成分的復合數據對象。請注意，一個序對也算一個數據對象。進一步說，還可以用cons去構造那種其元素本身就是序對的序對，並繼續這樣做下去。
（define x (cons 1 2)) //構造一個x序對，有1，2組成
（define y (cons 3 4))
(define z (cons x y))
Scheme可以建立元素本身也算序對的序對，這就是表結構得以作為一種表示工具的根本基礎。我們將這種能力稱為cons的閉包性質。一般說，某種組合數據對象的操作滿足閉包性質，那就是說，通過它組合起數據對象得到的結果本身還可以通過同樣的操作再進行組合。閉包性質是任何一種組合功能的威力的關鍵要素，因為它使我們能夠建立起層次性結構，這種結構由一些部分構成，而其中的各個部分又是由它們的部分構成，並且可以如此繼續下去。

Ⅷ 閉包是python的特性么其他語言中有么

不只是python，支持函數式編程的語言比如javascript，go，perl都有閉包，但細節不太一樣

Ⅸ 編程都有哪些語言

幾種常用編程語言簡單介紹

1.c語言

是一種計算機程序設計語言。它既具有高級語言的特點，又具有匯編語言的特點。它可以作為工作系統設計語言，編寫系統應用程序，也可以作為應用程序設計語言，編寫不依賴計算機硬體的應用程序。它的應用范圍廣泛，具備很強的數據處理能力，不僅僅是在軟體開發上，而且各類科研都需要用到c語言，始於編寫程序軟體，三維，二維圖形和動畫。具體應用比如單片機以及嵌入式系統開發。

優點：簡潔緊湊，靈活方便，運算符豐富，數據類型豐富，c是結構式語言，語法限制不太嚴格，程序設計自由度大，生成目標代碼質量高，程序執行效率高。

缺點：沒有面向對象編程功能（OOPs），運行時類型檢查是不可用，C不能夠在一個范圍內再次使用相同的變數名，構造函數和析構函數不可用，必須通過方法或者以其他方式來手動實現變數的析構和構造。

2.c++

是在c語言的基礎上開發的一種面向對象編程語言，應用廣泛。它的主要特點表現在兩個方面：一是盡量兼容c，二是支持面向對象的方法。它操持了c簡潔，高效的接近匯編語言等特點，對c的類型系統進行了改革的擴充。

應用領域：游戲，科學計算，網路軟體，分布式應用，操作系統，設備驅動程序，移動設備，嵌入式系統，教育與科研，部分行業應用，其他應用。

3.c#

是微軟對這一問題的解決方案。C#是一種最新的、面向對象的編程語言。

主要特點：簡單，現代，面向對象的，類型安全，相互兼容性，可伸縮性和可升級性。

主要領域：web應用，客戶端應用，分布式計算，人工智慧，各類游戲。

4.visual 語言

一種直譯式程序設計語言。名稱字面為意思「初學者的全方位符式指令代碼」，設計給初學者使用的編程語言，在完成編寫後不須經由編譯及鏈接等手續，經過解釋器即可運行，但如果需要單獨運行時仍然需要將其創建成可執行文件。

特點：（1）面向對象和可視化的程序設計。
（2）事件驅動的運行機制。
（3）結構化的程序設計語言。
（4）多種資料庫訪問能力。
（5）提供了功能完備的應用程序集成開發環境。
（6）方便使用的聯機幫助功能。

5.perl 語言

是一種解釋型的腳本語言。Perl語言由Larry wall干1986年開發成功。當初的目的主要是在Unix環境下，用於處理面向系統任務而設計的腳本編程語言。Perl對文件和字元有很強的處理、變換能力，它特別適用於有關系統管理、資料庫和網路互聯以及WWW程序設計等任務，這樣使得Perl稱為系統維護管理者和CGI編制者的首選工具語言。

特點：

1. Perl的解釋程序是開放源碼的免費軟體，使用Perl不必擔心費用。

2. Perl能在絕大多數操作系統運行，可以方便地向不同操作系統遷移。

3. Perl 是一種能完成任務的語言。從一開始，Perl 就設計成可以把簡單工作簡單化，同時又不失去處理困難問題能力的語言。它可以很容易操作數字，文本，文件和目錄，計算機和網路，特別是程序的語言。這種語言應該很容易運行外部的程序並且掃描這些程序的輸出獲取感興趣的東西。而且它還應該很容易能把這些你感興趣的東西交給其它程序做特殊的處理。當然，這種語言還應該很容易在任何現代的操作系統上可以移植地編譯和運行。

6.java

是一門面向對象編程語言，不僅吸收了c++語言的各種優點，還摒棄了c++里難以理解的多繼承，指針等概念，因此java語言具有功能強大和簡單易用兩個特徵。java語言作為靜態面向對象編程語言的代表，極好地實現了面向對象理論，允許程序員以優雅的思維方式進行復雜的編程。

特點：簡單性，面向對象，分布性，編譯和解釋性，穩健性，安全性，可移植性，高能性，多線索性，動態性。

應用：android應用，在金融業應用的伺服器程序，網站，嵌入式領域，大數據技術，高頻交易的空間，科學領域。

7.Objective-C

通常寫作ObjC或OC和較少用的Objective C或Obj-C，是擴充C的面向對象編程語言。它主要使用於Mac OS X和GNUstep這兩個使用OpenStep標準的系統，而在NeXTSTEP和OpenStep中它更是基本語言。

特點：1、動態運行環境，適合UI編程
在Objective-C中，如下語法並非單純的函數調用，而是向某對象發送消息。

2、方便與C/C++混合使用
Objective-C中的C擴展部分，使用符號@開頭。比如@class、@interface、@"Hello，World"。而它的消息發送語法則是使用中括弧而不是圓括弧。

3、運行速度相對較快
Objective-C編譯後是機器原生指令，運行時環境也小而緊湊。它採用引用計數的內存管理方式，並引入ARC。ARC比GC更容易引起編程錯誤，但卻比GC快。而在性能很重要的場合，Objective-C也很容易直接調用C/C++代碼。相對於其他使用虛擬機、採用GC以及間接調用C/C++的移動平台，速度優勢非常明顯。

應用：ios操作系統，ios應用程序，mac os x操作系統，mac osx上的應用程序。

8.PHP

是一種通用開源腳本語言。語法吸收了C語言、Java和Perl的特點，利於學習，使用廣泛，主要適用於Web開發領域。PHP 獨特的語法混合了C、Java、Perl以及PHP自創的語法。它可以比CGI或者Perl更快速地執行動態網頁。用PHP做出的動態頁面與其他的編程語言相比，PHP是將程序嵌入到HTML（標准通用標記語言下的一個應用）文檔中去執行，執行效率比完全生成HTML標記的CGI要高許多；PHP還可以執行編譯後代碼，編譯可以達到加密和優化代碼運行，使代碼運行更快。

特點：

1. PHP 獨特的語法混合了 C、Java、Perl 以及 PHP 自創新的語法。
2. PHP可以比CGI或者Perl更快速的執行動態網頁——動態頁面方面，與其他的編程語言相比，
PHP是將程序嵌入到HTML文檔中去執行，執行效率比完全生成htmL標記的CGI要高許多；
PHP具有非常強大的功能，所有的CGI的功能PHP都能實現。
3. PHP支持幾乎所有流行的資料庫以及操作系統。
4. 最重要的是PHP可以用C、C++進行程序的擴展！

9.python

是一種面向對象的解釋型計算機程序設計語言，由荷蘭人Guido van Rossum於1989年發明，第一個公開發行版發行於1991年。

Python是純粹的自由軟體， 源代碼和解釋器CPython遵循 GPL(GNU General Public License)協議 。Python語法簡潔清晰，特色之一是強制用空白符(white space)作為語句縮進。
特點：簡單，易學，速度快，免費、開發，高層語言，可移植性，解釋性，面向對象，可擴展性。
應用：
系統編程，圖形處理，數學處理，文本處理，資料庫編程，網路編程，多媒體應用，pymo引擎，黑客編程。

10.ruby

是一種簡單快捷的面向對象（面向對象程序設計）腳本語言，在20世紀90年代由日本人松本行弘(Yukihiro Matsumoto)開發，遵守GPL協議和Ruby License。它的靈感與特性來自於Perl、Smalltalk、Eiffel、Ada以及Lisp 語言。

優點
語法簡單，普通的面向對象功能(類,方法調用等)，特殊的面向對象功能(Mixin,特殊方法等，操作符重載，錯誤處理功能迭代器和閉包，垃圾回收，動態載入，可移植性高。

Ⅹ 編程：求一個關系的傳遞閉包（C語言）

利用關系的矩陣表示，可以通過Warshall演算法計算有限集合上的二元關系的傳遞閉包。