本文面向的讀者：學習過C++程序設計語言（也就是說學習過Template），但是還沒有接觸過STL的STL的初學者。這實際上是我學習STL的一篇筆記，老鳥就不用看了。
什麼是泛型程序設計
我們可以簡單的理解為：使用模板的程序設計就是泛型程序設計。就像我們我們可以簡單的理解面向對象程序設計就是使用虛函數的程序設計一樣。
STL是什麼
作為一個C++程序設計者，STL是一種不可忽視的技術。Sandard Template Library (STL)：
標准模板庫,更准確的說是 C++ 程序設計語言標准模板庫。學習過MFC的人知道，MFC是微軟公司創建的 C++ 類庫。而與之類似的是 STL 是模板庫，只不過 STL 是 ANSI/ISO 標准的一部分，而 MFC 只不過是微軟的一個產品而已。也就是說STL是所有C++編譯器和所有操作系統平台都支持的一種庫，說它是一種庫是因為，雖然STL是一種標准，也就是說對所有的編譯器來說，提供給C++程序設計者的接口都是一樣的。也就是說同一段STL代碼在不同編譯器和操作系統平台上運行的結果都是相同的，但是底層實現可以是不同的。 令人興奮的是，STL的使用者並不需要了解它的底層實現。 試想一下，如果我們有一把能打開所有鎖的鑰匙，那將是多麼令人瘋狂啊。嘎嘎。這個歪夢我做了20多年鳥。
STL的目的是標准化組件，這樣你就不用重新開發它們了。你可以僅僅使用這些現成的組件。STL現在是C++的一部分，因此不用額外安裝什麼。它被內建在你的編譯器之內。
為什麼我們需要學習STL
STL是 C++的ANSI/ISO 標准的一部分,可以用於所有C++語言編譯器和所有平台(Windows/Unix/Linux..)。STL的同一版本在任意硬件配置下都是可用的；
STL 提供了大量的可復用軟件組織。例如，程序員再也不用自己設計排序，搜索算法了，這些都已經是STL的一部分了。嘎嘎，有意思吧；
使用STL 的應用程序保證了得到的實現在處理速度和內存利用方面都是高效的，因為STL設計者們已經為我們考慮好了；
使用STL編寫的代碼更容易修改和閱讀，這是當然的鳥。因為代碼更短了，很多基礎工作代碼已經被組件化了；
使用簡單，雖然內部實現很復雜；
雖然，STL的優點甚多，但是STL的語法實在令初學者人頭疼，許多人望而卻步。可是STL是每個C++程序設計者遲早都要啃的一塊骨頭。因為越來越多的C++代碼是用STL編寫的，看不懂麻煩就大鳥。越來越多的人在用STL，不懂就無法和別人一起合作了。好事多磨嘛，早點學習早點解脫。
下面讓我們來看幾段代碼吧：（你覺得頭疼就不要看了）
//stl_cpp_1.cpp
#include <iostream>
double mean(double *array, size_t n)
{
double m=0;
for(size_t i=0; i<n; ++i){
m += array[i];
}
return m/n;
}
int main(void)
{
double a[] = {1, 2, 3, 4, 5};
std::cout<<mean(a, 5)<<std::endl; // will print 3
return 0;
}
好懂吧，除了那個std有點讓人不舒服以外？這是一段普通的沒有使用STL的C++代碼。再看下面一段：
//stl_cpp_2.cpp
#include <vector>
#include <iostream>
int main(void)
{
std::vector<double> a;
std::vector<double>::const_iterator i;
a.push_back(1);
a.push_back(2);
a.push_back(3);
a.push_back(4);
a.push_back(5);
for(i=a.begin(); i!=a.end(); ++i){
std::cout<<(*i)<<std::endl;
}
return 0;
}
如果你真的沒有接觸過STL的話，你會問，呀，vector 是啥呀？我會告訴你，那是一排美女。嘎嘎。這可不是個比喻，表想歪鳥。這是一段純種的STL代碼，看到尖括號了吧，知道那是模板了吧。看到a.push_back(5),a.begin(),a.end()你不感覺奇怪麼？可是我們並沒有定義這些函數啊。
//stl_cpp_3.cpp
#include <vector>
#include <iostream>
int main(void)
{
std::vector<int> q;
q.push_back(10);
q.push_back(11);
q.push_back(12);
std::vector<int> v;
for(int i=0; i<5; ++i){
v.push_back(i);
}
std::vector<int>::iterator it = v.begin() + 1;
it = v.insert(it, 33);
v.insert(it, q.begin(), q.end());
it = v.begin() + 3;
v.insert(it, 3, -1);
it = v.begin() + 4;
v.erase(it);
it = v.begin() + 1;
v.erase(it, it + 4);
v.clear();
return 0;
}
這一段你又看到了新東西了吧，iterator？？？不羅嗦了，等你看完這篇文章，回頭再看就簡單了。在正式介紹STL之前，我們需要花點時間來了解一下模板和命名空間。
關於模板的其他細節，讀者可以參閱《C++ Templates 中文版》（有點費腦子哦）。在這裡，我只簡單的介紹一下模板類和函數模板的概念。
模板是C++中實現代碼重用機制的一種工具，可以實現類型參數化，把類型定義為參數。函數模板和類模板允許用戶構造模板函數和模板類。
圖1
下面我們來看一段函數模板的例子：
//stl_cpp_4.cpp
#include<iostream.h>
#include<string.h>
//定義函數模板
template<class T> //template 是關鍵字，T 表示一種待實例化的類型
//template<typename T> 也是對的
T max(T a, T b)//函數模板，函數名為 max，此函數有2個T類型的參數，返回類型為T
{
return (a>b)?a:b;
}
//在此例實例化的時候，T可以是多種類型的，int,char,string…
int main(void)
{
int x=2,y=6;
double x1=9.123,y1=12.6543;
cout<<"把T實例化為int:"<<max(x,y)<<endl;//實例化函數模板，把T實例化為int
cout<<"把T實例化為double:"<<max(x1,y1)<<endl;
//實例化函數模板，把T實例化為double
getchar(); //這一行代碼用來在dos下查看結果，也可以用cin.get();
}
下面再看看，類模板：
//stl_cpp_5.cpp
#include<iostream.h>
//定義名為ex_class的類模板
template < typename T> class ex_class
{
T value;
public:
ex_class(T v) { value=v; }
void set_value(T v) { value=v; }
T get_value(void) {return value;}
};
//main()函數中測試ex_class類模板
int main(void)
{
//測試int類型數據
ex_class <int> a(5),b(10);
cout<<"a.value:"<<a.get_value()<<endl;
cout<<"b.value:"<<b.get_value()<<endl;
//測試char類型數據
ex_class <char> ch(''A'');
cout<<"ch.value:"<<ch.get_value()<<endl;
ch.set_value(''a'');
cout<<"ch.value:"<<ch.get_value()<<endl;
//測試double類型數據
ex_class <double> x(5.5);
cout<<"x.value:"<<x.get_value()<<endl;
x.set_value(7.5);
cout<<"x.value:"<<x.get_value()<<endl;
}
命名空間（名字空間）
命名空間是C++的一種機制，用來把單個標識符下的大量有邏輯聯系的程序實體組合到一起。此標識符作為此組群的名字。命名空間用關鍵字namespace 來定義：
//stl_cpp_6.cpp
#include <iostream>
using namespace std;
namespace printA
{
print() {cout<<"using namespace printA….."<<endl; };
}
namespace printB
{
print() {cout<<"using namespace printB….."<<endl; };
}
int main(void)
{
printA::print(); //測試命名空間printA， ：：是作用域解析運算符
printB::print();
}
命名空間可以嵌套定義：
namespace A
{
functiong1(){};
namespace B
{ }
}
一個namespace是指一個具名的范圍（named scope）。namespace被用來將相關的聲明劃歸在一起，將不相關的代碼部分隔開。命名空間只是命名了一個特殊的作用域，當程序很大，而且需要多人合作的時候，命名空間就顯得特別的重要。比如2個程序員A,B 在同一個程序中定義了函數 pop(),如果沒有使用命名空間，則會出錯，而且這種錯誤難以檢測出來。為了安全起見，他們可以定義不同的命名空間 A和B，在用的時候可以使用A::pop()和B::pop()來區分。
在STL中，標准庫的全部成員在預先定義的命名空間std中。如果要用類模板vector ，有兩種方法：一是在程序的前面添加預處理指令：
#include <vector>
using namespace std;
第二種方法是：
#include <vector>
using std::vector;
動態綁定和靜態綁定
所謂綁定是指，對於參與多態行為的類型，他們具有多態行為的接口是在公共基類的設計中就預先確定的。而非綁定則對於參與多態行為的類型，他們的接口沒有預先定義。
在C++中通過繼承實現的多態是動態綁定，通過模板實現的多態是靜態綁定。動態綁定的接口是在運行期間（動態）完成的，靜態綁定的接口是在編譯期間（靜態）完成的。好了，有了以上的知識我們可以來學習STL 了。
STL 的組成
STL有三大核心部分：容器（Container）、算法（Algorithms）、迭代器（Iterator），容器適配器（container adaptor），函數對象(functor)，除此之外還有STL其他標准組件。
容器：裝東西的東西，裝水的杯子，裝鹹水的大海，裝人的教室……STL裡的容器是可容納一些數據的模板類；
算法：就是往杯子裡倒水，往大海裡排污，從教室裡攆人……STL裡的算法，就是處理容器裡面數據的方法，操作；
迭代器：往杯子裡倒水的水壺，排污的管道，攆人的那個物業管理人員……STL裡的迭代器：遍歷容器中數據的對象；
對存儲於容器中的數據進行處理時，迭代器能從一個成員移向另一個成員。他能按預先定義的順序在某些容器中的成員間移動。對普通的一維數組、向量、雙端隊列和列表來說，迭代器是一種指針。
知道了吧？嘎嘎，當然了，你猜到了，那是我在瞎扯蛋。
下面讓我們來看看專家是怎麼說的：
容器（container）：容器是數據在內存中組織的方法，例如，數組、堆棧、隊列、鏈表或二叉樹（不過這些都不是STL標准容器）。STL中的容器是一種存儲T（Template）類型值的有限集合的數據結構,容器的內部實現一般是類。這些值可以是對象本身，如果數據類型T代表的是Class的話。
算法（algorithm）：算法是應用在容器上以各種方法處理其內容的行為或功能。例如，有對容器內容排序、復制、檢索和合並的算法。在STL中，算法是由模板函數表現的。這些函數不是容器類的成員函數。相反，它們是獨立的函數。令人吃驚的特點之一就是其算法如此通用。不僅可以將其用於STL容器，而且可以用於普通的C＋＋數組或任何其他應用程序指定的容器。
迭代器(iterator)：一旦選定一種容器類型和數據行為(算法)，那麼剩下唯一要他做的就是用迭代器使其相互作用。可以把達代器看作一個指向容器中元素的普通指針。可以如遞增一個指針那樣遞增迭代器，使其依次指向容器中每一個後繼的元素。迭代器是STL的一個關鍵部分，因為它將算法和容器連在一起。
下面我將依次介紹STL的這三個主要組件。
容器
STL中的容器有隊列容器和關聯容器，容器適配器（congtainer adapters：stack,queue，priority queue），位集（bit_set），串包(string_package)等等。
在本文中，我將介紹list,vector，deque等隊列容器，和set和multisets,map和multimaps等關聯容器，一共7種基本容器類。
隊列容器（順序容器）：隊列容器按照線性排列來存儲T類型值的集合，隊列的每個成員都有自己的特有的位置。順序容器有向量類型、雙端隊列類型、列表類型三種。
基本容器——順序容器
向量（vector容器類）：＃include <vector>，vector是一種動態數組，是基本數組的類模板。其內部定義了很多基本操作。既然這是一個類，那麼它就會有自己的構造函數。vector 類中定義了4中種構造函數：
默認構造函數，構造一個初始長度為0的空向量，
如：vector<int> v1;
帶有單個整形參數的構造函數，此參數描述了向量的初始大小。這個構造函數還有一個可選的參數，這是一個類型為T的實例，描述了各個向量種各成員的初始值；
如：vector<int> v2(init_size,0); 如果預先定義了：int init_size;他的成員值都被初始化為0；
復制構造函數，構造一個新的向量，作為已存在的向量的完全復制，
如：vector<int> v3(v2);
帶兩個常量參數的構造函數，產生初始值為一個區間的向量。區間由一個半開區間[first,last](MS word的顯示可能會有問題，first前是一個左方括號，last後面是一個右圓括號)來指定。
如：vector<int> v4（first,last）
下面一個例子用的是第四種構造方法，其它的方法讀者可以自己試試。
//stl_cpp_7.cpp
//程序：初始化演示
#include <cstring>
#include <vector>
#include <iostream>
using namespace std;
int ar[10] = { 12, 45, 234, 64, 12, 35, 63, 23, 12, 55 };
char* str = "Hello World";
int main(void)
{
vector <int> vec1(ar, ar+10); //first=ar,last=ar+10,不包括ar+10
vector <char> vec2(str, str+strlen(str)); //first=str,last= str+strlen(str),不包括最後一個
cout<<"vec1:"<<endl;
//打印vec1和vec2，const_iterator是迭代器，後面會講到
//當然，也可以用for (int i=0; i<vec1.size(); i++)cout << vec[i];輸出
//size()是vector的一個成員函數
for(vector<int>::const_iterator p=vec1.begin();p!=vec1.end(); ++p)
cout<<*p;
cout<<''\n ''<<"vec2:"<<endl;
for(vector<char>::const_iterator p1=vec2.begin();p1!=vec2.end(); ++p1)
cout<<*p1;
getchar();
return 0;
}
為了幫助理解向量的概念，這裡寫了一個小例子，其中用到了vector的成員函數：begin()，end()，push_back()，assign()，front()，back()，erase()，empty()，at()，size()。
//stl_cpp_8.cpp
#include <iostream>
#include <vector>
using namespace std;
typedef vector<int> INTVECTOR;//自定義類型INTVECTOR
//測試vector容器的功能
void main(void)
{
//vec1對象初始為空
INTVECTOR vec1;
//vec2對象最初有10個值為6的元素
INTVECTOR vec2(10,6);
//vec3對象最初有3個值為6的元素，拷貝構造
INTVECTOR vec3(vec2.begin(),vec2.begin()+3);
//聲明一個名為i的雙向迭代器
INTVECTOR::iterator i;
//從前向後顯示vec1中的數據
cout<<"vec1.begin()--vec1.end():"<<endl;
for (i =vec1.begin(); i !=vec1.end(); ++i)
cout << *i << " ";
cout << endl;
//從前向後顯示vec2中的數據
cout<<"vec2.begin()--vec2.end():"<<endl;
for (i =vec2.begin(); i !=vec2.end(); ++i)
cout << *i << " ";
cout << endl;
//從前向後顯示vec3中的數據
cout<<"vec3.begin()--vec3.end():"<<endl;
for (i =vec3.begin(); i !=vec3.end(); ++i)
cout << *i << " ";
cout << endl;
//測試添加和插入成員函數，vector不支持從前插入
vec1.push_back(2);//從後面添加一個成員
vec1.push_back(4);
vec1.insert(vec1.begin()+1,5);//在vec1第一個的位置上插入成員5
//從vec1第一的位置開始插入vec3的所有成員
vec1.insert(vec1.begin()+1,vec3.begin(),vec3.end());
cout<<"after push() and insert() now the vec1 is:" <<endl;
for (i =vec1.begin(); i !=vec1.end(); ++i)
cout << *i << " ";
cout << endl;
//測試賦值成員函數
vec2.assign(8,1); // 重新給vec2賦值，8個成員的初始值都為1
cout<<"vec2.assign(8,1):" <<endl;
for (i =vec2.begin(); i !=vec2.end(); ++i)
cout << *i << " ";
cout << endl;
//測試引用類函數
cout<<"vec1.front()="<<vec1.front()<<endl;//vec1第零個成員
cout<<"vec1.back()="<<vec1.back()<<endl;//vec1的最後一個成員
cout<<"vec1.at(4)="<<vec1.at(4)<<endl;//vec1的第五個成員
cout<<"vec1[4]="<<vec1[4]<<endl;
//測試移出和刪除
vec1.pop_back();//將最後一個成員移出vec1
vec1.erase(vec1.begin()+1,vec1.end()-2);//刪除成員
cout<<"vec1.pop_back() and vec1.erase():" <<endl;
for (i =vec1.begin(); i !=vec1.end(); ++i)
cout << *i << " ";
cout << endl;
//顯示序列的狀態信息
cout<<"vec1.size(): "<<vec1.size()<<endl;//打印成員個數
cout<<"vec1.empty(): "<<vec1.empty()<<endl;//清空
}
雙端隊列（qeque容器類）：#include <deque>
deque（讀音：deck，意即：double queue）容器類與vector類似，支持隨機訪問和快速插入刪除，它在容器中某一位置上的操作所花費的是線性時間。與vector不同的是，deque還支持從開始端插入數據：
push_front()。此外deque也不支持與vector的capacity()、reserve()類似的操作。
//stl_cpp_9.cpp
#include <iostream>
#include <deque>
using namespace std;
typedef deque<int> INTDEQUE;//有些人很討厭這種定義法，呵呵
//從前向後顯示deque隊列的全部元素
void put_deque(INTDEQUE deque, char *name)
{
INTDEQUE::iterator pdeque;//仍然使用迭代器輸出
cout << "The contents of " << name << " : ";
for(pdeque = deque.begin(); pdeque != deque.end(); pdeque++)
cout << *pdeque << " ";//注意有 "*"號哦，沒有"*"號的話會報錯
cout<<endl;
}
//測試deqtor容器的功能
void main(void)
{
//deq1對象初始為空
INTDEQUE deq1;
//deq2對象最初有10個值為6的元素
INTDEQUE deq2(10,6);
//deq3對象最初有3個值為6的元素
//聲明一個名為i的雙向迭代器變量
INTDEQUE::iterator i;
//從前向後顯示deq1中的數據
put_deque(deq1,"deq1");
//從前向後顯示deq2中的數據
put_deque(deq2,"deq2");
//從deq1序列後面添加兩個元素
deq1.push_back(2);
deq1.push_back(4);
cout<<"deq1.push_back(2) and deq1.push_back(4):"<<endl;
put_deque(deq1,"deq1");
//從deq1序列前面添加兩個元素
deq1.push_front(5);
deq1.push_front(7);
cout<<"deq1.push_front(5) and deq1.push_front(7):"<<endl;
put_deque(deq1,"deq1");
//在deq1序列中間插入數據
deq1.insert(deq1.begin()+1,3,9);
cout<<"deq1.insert(deq1.begin()+1,3,9):"<<endl;
put_deque(deq1,"deq1");
//測試引用類函數
cout<<"deq1.at(4)="<<deq1.at(4)<<endl;
cout<<"deq1[4]="<<deq1[4]<<endl;
deq1.at(1)=10;
deq1[2]=12;
cout<<"deq1.at(1)=10 and deq1[2]=12 :"<<endl;
put_deque(deq1,"deq1");
//從deq1序列的前後各移去一個元素
deq1.pop_front();
deq1.pop_back();
cout<<"deq1.pop_front() and deq1.pop_back():"<<endl;
put_deque(deq1,"deq1");
//清除deq1中的第2個元素
deq1.erase(deq1.begin()+1);
cout<<"deq1.erase(deq1.begin()+1):"<<endl;
put_deque(deq1,"deq1");
//對deq2賦值並顯示
deq2.assign(8,1);
cout<<"deq2.assign(8,1):"<<endl;
put_deque(deq2,"deq2");
}
上面我們演示了deque如何進行插入刪除等操作，像erase(),assign()是大多數容器都有的操作。關於deque的其他操作請參閱附錄。
表（List容器類）：#include <list>
List又叫鏈表，是一種雙線性列表，只能順序訪問（從前向後或者從後向前），圖2是list的數據組織形式。與 前面兩種容器類有一個明顯的區別就是：它不支持隨機訪問。要訪問表中某個下標處的項需要從表頭或表尾處（接近該下標的一端）開始循環。而且缺少下標預算符：operator[]。
圖2
同時，list仍然包涵了erase(),begin(),end(),insert(),push_back(),push_front()這些基本函數，下面我們來演示一下list的其他函數功能。
merge()：合並兩個排序列表；
splice()：拼接兩個列表；
sort()：列表的排序；
//stl_cpp_10.cpp
#include <iostream>
#include <string>
#include <list>
using namespace std;
void PrintIt(list<int> n)
{
for(list<int>::iterator iter=n.begin(); iter!=n.end(); ++iter)
cout<<*iter<<" ";//用迭代器進行輸出循環
}
int main(void)
{
list<int> listn1,listn2;
//給listn1,listn2初始化
listn1.push_back(123);
listn1.push_back(0);
listn1.push_back(34);
listn1.push_back(1123);
//now listn1:123,0,34,1123
listn2.push_back(100);
listn2.push_back(12);
//now listn2:12,100
listn1.sort();
listn2.sort();
//給listn1和listn2排序
//now listn1:0,34,123,1123 listn2:12,100
PrintIt(listn1);
cout<<endl;
PrintIt(listn2);
listn1.merge(listn2);
//合並兩個排序列表後,listn1:0，12，34，100，123，1123
cout<<endl;
PrintIt(listn1);
cin.get();
}
上面並沒有演示splice()函數的用法，這是一個拗口的函數。用起來有點麻煩。圖3所示是splice函數的功能。將一個列表插入到另一個列表當中。list容器類定義了splice()函數的3個版本：
splice(position,list_value);
splice(position,list_value,ptr);
splice(position,list_value,first,last);
list_value是一個已存在的列表，它將被插入到源列表中，position是一個迭代參數，他當前指向的是要進行拼接的列表中的特定位置。
圖3
listn1:123,0,34,1123 listn2:12,100
執行listn1.splice(find(listn1.begin(),listn1.end(),0),listn2);之後，listn1將變為：123，12，100，34，1123。即把listn2插入到listn1的0這個元素之前。其中，find()函數找到0這個元素在listn1中的位置。值得注意的是，在執行splice之後，list_value將不復存在了。這個例子中是listn2將不再存在。
第二個版本當中的ptr是一個迭代器參數，執行的結果是把ptr所指向的值直接插入到position當前指向的位置之前.這將只向源列表中插入一個元素。
第三個版本的first和last也是迭代器參數，並不等於list_value.begin(),list_value.end()。First指的是要插入的列的第一個元素，last指的是要插入的列的最後一個元素。
如果listn1:123,0,34,1123 listn2:12,43，87，100 執行完以下函數之後
listn1.splice(find(listn1.begin(),listn1.end(),0),++listn2.begin(),--listn2.end());
listn1:123,43,87,0,34,1123 listn2:12,100
以上，我們學習了vector,deque,list三種基本順序容器，其他的順序容器還有：slist,bit_vector等等。
另一種容器——關聯容器（有點費解哦，出去讓腦子清醒一下再回來看）
與前面講到的順序容器相比，關聯容器更注重快速和高效地檢索數據的能力。這些容器是根據鍵值（key）來檢索數據的，鍵可以是值也可以是容器中的某一成員。這一類中的成員在初始化後都是按一定順序排好序的。
集和多集（set 和multiset 容器類）：#include <set>
一個集合（set）是一個容器，它其中所包含的元素的值是唯一的。這在收集一個數據的具體值的時候是有用的。集合中的元素按一定的順序排列，並被作為集合中的實例。如果你需要一個鍵/值對（pair）來存儲數據，map（也是一個關聯容器，後面將馬上要講到）是一個更好的選擇。一個集合通過一個鏈表來組織，在插入操作和刪除操作上比向量（vector）快，但查找或添加末尾的元素時會有些慢。
在集中，所有的成員都是排列好的。如果先後往一個集中插入：12，2，3，123，5，65
則輸出該集時為：2，3，5，12，65，123
集和多集的區別是：set支持唯一鍵值，set中的值都是特定的，而且只出現一次；而multiset中可以出現副本鍵，同一值可以出現多次。
Set和multiset的模板參數：
template<class key, class compare, class Allocator=allocator>
第一個參數key是所存儲的鍵的類型，第二個參數是為排序值而定義的比較函數的類型，第三個參數是被實現的存儲分配符的類型。在有些編譯器的具體實現中，第三個參數可以省略。第二個參數使用了合適形式的迭代器為鍵定義了特定的關系操作符，並用來在容器中遍歷值時建立順序。集的迭代器是雙向，同時也是常量的，所以迭代器在使用的時候不能修改元素的值。
Set定義了三個構造函數：
默認構造函數：
explicit set(const Compare&=compare());
如：set<int,less<int> > set1;
less<int>是一個標准類，用於形成降序排列函數對象。升序排列是用greater<int>。通過指定某一預先定義的區間來初始化set對象的構造函數：
template<class InputIterator> set(InputIterator, InputIterator,\ const Compare&=compare());
如：set<int ,less<int> >set2(vector1.begin(),vector1.end());
復制構造函數：
set（const set<Key,Compare&>）;
如：set<int ,less<int> >set3(set2);
下面我們來看一個簡單的集和多集的插入例程：
//stl_cpp_11.cpp
#include <iostream>
#include <set>
using namespace std;
int main(void)
{
set<int> set1;
for(int i=0; i<10; ++i)
set1.insert(i);
for(set<int>::iterator p=set1.begin();p!=set1.end();++p)
cout<<*p<<"";
if(set1.insert(3).second)//把3插入到set1中
//插入成功則set1.insert(3).second返回1，否則返回0
//此例中，集中已經有3這個元素了，所以插入將失敗
cout<<"set insert success";
else
cout<<"set insert failed";
int a[] = {4, 1, 1, 1, 1, 1, 0, 5, 1, 0};
multiset<int> A;
A.insert(set1.begin(),set1.end());
A.insert(a,a+10);
cout<<endl;
for(multiset<int>::iterator p=A.begin();p!=A.end();++p)
cout<<*p<<" ";
cin.get();
return 0;
}
在集之間可以進行並集（set_union()）、交集(set_intersection())、差集(set_diffrence())d等操作，功能強大。
映射和多重映射（map 和multimap）：#include <map>
映射和多重映射基於某一類型Key的鍵集的存在，提供對T類型的數據進行快速和高效的檢索。對map而言，鍵只是指存儲在容器中的某一成員。Map不支持副本鍵，multimap支持副本鍵。Map和multimap對象包涵了鍵和各個鍵有關的值，鍵和值的數據類型是不相同的，這與set不同。set中的key和value是Key類型的，而map中的key和value是一個pair結構中的兩個分量。Map支持下表運算符operator[],用訪問普通數組的方式訪問map，不過下標為map的鍵。在multimap中一個鍵可以對應多個不同的值。
下面的例程說明了map中鍵與值的關系。
//stl_cpp_12.cpp
#include <iostream>
#include <map>
using namespace std;
int main(void)
{
map<char,int,less<char> > map1;
map<char,int,less<char> >::iterator mapIter;
//char 是鍵的類型，int是值的類型
//下面是初始化，與數組類似
//也可以用map1.insert(map<char,int,less<char> >::value_type(''c'',3));
map1[''c'']=3;
map1[''d'']=4;
map1[''a'']=1;
map1[''b'']=2;
for(mapIter=map1.begin();mapIter!=map1.end();++mapIter)
cout<<" "<<(*mapIter).first<<": "<<(*mapIter).second;
//first對應定義中的char鍵，second對應定義中的int值
//檢索對應於d鍵的值是這樣做的：
map<char,int,less<char> >::const_iterator ptr;
ptr=map1.find(''d'');
cout<<''\n ''<<" "<<(*ptr).first<<" 鍵對應於值："<<(*ptr).second;
cin.get();
return 0;
}
從以上例程中，我們可以看到map對象的行為和一般數組的行為類似。Map允許兩個或多個值使用比較操作符。下面我們再看看multimap:
//stl_cpp_13.cpp
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main(void)
{
multimap<string,string,less<string> >mulmap;
multimap<string,string,less<string> >::iterator p;
//初始化多重映射mulmap:
typedef multimap<string,string,less<string> >::value_type vt;
typedef string s;
mulmap.insert(vt(s("Tom "),s("is a student")));
mulmap.insert(vt(s("Tom "),s("is a boy")));
mulmap.insert(vt(s("Tom "),s("is a bad boy of blue!")));
mulmap.insert(vt(s("Jerry "),s("is a student")));
mulmap.insert(vt(s("Jerry "),s("is a beatutiful girl")));
mulmap.insert(vt(s("DJ "),s("is a student")));
//輸出初始化以後的多重映射mulmap:
for(p=mulmap.begin();p!=mulmap.end();++p)
cout<<(*p).first<<(*p).second<<endl;
//檢索並輸出Jerry鍵所對應的所有的值
cout<<"find Jerry :"<<endl;
p=mulmap.find(s("Jerry "));
while((*p).first=="Jerry ")
{
cout<<(*p).first<<(*p).second<<endl;
++p;
}
cin.get();
return 0;
}
在map中是不允許一個鍵對應多個值的，在multimap中，不支持operator[],也就是說不支持map中允許的下標操作。
算法（algorithm）：#inlcude <algorithm>
STL中算法的大部分都不作為某些特定容器類的成員函數，他們是泛型的，每個算法都有處理大量不同容器類中數據的使用。值得注意的是，STL中的算法大多有多種版本，用戶可以依照具體的情況選擇合適版本。中在STL的泛型算法中有4類基本的算法：
變序型隊列算法，可以改變容器內的數據；
非變序型隊列算法，處理容器內的數據而不改變他們；
排序值算法，包涵對容器中的值進行排序和合並的算法，還有二叉搜索算法 $$通用數值算法；
注：STL的算法並不只是針對STL容器，對一般容器也是適用的。
變序型隊列算法（mutating algorithms）：
又叫可修改的序列算法。這類算法有復制（copy）算法、交換（swap）算法、替代（replace）算法、刪除（remove）算法，移動（transfer）算法、翻轉（reverse）算法等等。這些算法可以改變容器中的數據（數據值和值在容器中的位置）。下面介紹2個比較常用的算法reverse()和copy()。
//stl_cpp_14.cpp
#include <iostream>
#include <algorithm>
#include <iterator>//下面用到了輸出迭代器ostream_iterator
using namespace std;
int main(void)
{
int arr[6]={1,12,3,2,1215,90};
int arr1[7];
int arr2[6]={2,5,6,9,0,-56};
copy(arr,(arr+6),arr1);//將數組aar復制到arr1
cout<<"arr[6] copy to arr1[7],now arr1: "<<endl;
for(int i=0;i<7;i++)
cout<<" "<<arr1[i];
reverse(arr,arr+6);//將排好序的arr翻轉
cout<<''\n ''<<"arr reversed ,now arr:"<<endl;
copy(arr,arr+6,ostream_iterator<int>(cout, " "));//復制到輸出迭代器
swap_ranges(arr,arr+6,arr2);//交換arr和arr2序列
cout<<''\n ''<<"arr swaped to arr2,now arr:"<<endl;
copy(arr,arr+6,ostream_iterator<int>(cout, " "));
cout<<''\n ''<<"arr2:"<<endl;
copy(arr2,arr2+6,ostream_iterator<int>(cout, " "));
cin.get();
return 0;
}
revese()的功能是將一個容器內的數據順序翻轉過來，它的原型是：
template<class Bidirectional >
void reverse(Bidirectional first, Bidirectional last);
將first和last之間的元素翻轉過來，上例中你也可以只將arr中的一部分進行翻轉：
reverse(arr+3,arr+6);這也是有效的。First和last需要指定一個操作區間。
Copy()是要將一個容器內的數據復制到另一個容器內，它的原型是：
Template<class InputIterator ，class OutputIterator>
OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result);
它把[first,last－1]內的隊列成員復制到區間[result,result+(last-first)-1]中。泛型交換算法：Swap()操作的是單值交換，它的原型是：
template<class T>
void swap(T& a,T& b);
swap_ranges()操作的是兩個相等大小區間中的值，它的原型是：
template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 swap_ranges(ForwardIterator1 first1,ForwardIterator1 last1,\
ForwardIterator1 first2);
交換區間[first1,last1-1]和[first2, first2+(last1-first1)-1]之間的值，並假設這兩個區間是不重疊的。
非變序型隊列算法（Non-mutating algorithm）：
又叫不可修改的序列算法。這一類算法操作不影響其操作的容器的內容，包括搜索隊列成員算法，等價性檢查算法，計算隊列成員個數的算法。我將用下面的例子介紹其中的find(),search(),count()：
//stl_cpp_15.cpp
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void)
{
int a[10]={12,31,5,2,23,121,0,89,34,66};
vector<int> v1(a,a+10);
vector<int>::iterator result1,result2;//result1和result2是隨機訪問迭代器
result1=find(v1.begin(),v1.end(),2);
//在v1中找到2，result1指向v1中的2
result2=find(v1.begin(),v1.end(),8);
//在v1中沒有找到8，result2指向的是v1.end()
cout<<result1-v1.begin()<<endl; //3－0＝3或4－1＝3，屏幕結果是3
cout<<result2-v1.end()<<endl;
int b[9]={5,2,23,54,5,5,5,2,2};
vector<int> v2(a+2,a+8);
vector<int> v3(b,b+4);
result1=search(v1.begin(),v1.end(),v2.begin(),v2.end());
cout<<*result1<<endl;
//在v1中找到了序列v2，result1指向v2在v1中開始的位置
result1=search(v1.begin(),v1.end(),v3.begin(),v3.end());
cout<<*(result1-1)<<endl;
//在v1中沒有找到序列v3，result指向v1.end(),屏幕打印出v1的最後一個元素66
vector<int> v4(b,b+9);
int i=count(v4.begin(),v4.end(),5);
int j=count(v4.begin(),v4.end(),2);
cout<<"there are "<<i<<" members in v4 equel to 5"<<endl;
cout<<"there are "<<j<<" members in v4 equel to 2"<<endl;
//計算v4中有多少個成員等於 5,2
cin.get();
return 0;
}
find()的原型是：
template<class InputIterator，class EqualityComparable>
InputIterator find(InputIterator first, InputIterator last,\
const EqualityComparable& value);
其功能是在序列[first,last-1]中查找value值，如果找到，就返回一個指向value在序列中第一次出現的迭代，如果沒有找到，就返回一個指向last的迭代（last並不屬於序列）。 search()的原型是：
template <class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2);
其功能是在源序列[first1,last1-1]查找目標序列[first2，last2-1]如果查找成功，就返回一個指向源序列中目標序列出現的首位置的迭代。查找失敗則返回一個指向last的迭代。 Count()的原型是：
template <class InputIterator, class EqualityComparable>
iterator_traits<InputIterator>::difference_type count(InputIterator first,\
InputIterator last, const EqualityComparable& value);
其功能是在序列[first,last-1]中查找出等於value的成員，返回等於value得成員的個數。
排序算法（sort algorithm）：
這一類算法很多，功能強大同時也相對復雜一些。這些算法依賴的是關系運算。在這裡我只介紹其中比較簡單的幾種排序算法：sort(),merge(),includes()
//stl_cpp_16.cpp
#include <iostream>
#include <algorithm>
using namespace std;
int main(void)
{
int a[10]={12,0,5,3,6,8,9,34,32,18};
int b[5]={5,3,6,8,9};
int d[15];
sort(a,a+10);
for(int i=0;i<10;i++)
cout<<" "<<a[i];
sort(b,b+5);
if(includes(a,a+10,b,b+5))
cout<<''\n ''<<"sorted b members are included in a."<<endl;
else
cout<<"sorted a dosn`t contain sorted b!";
merge(a,a+10,b,b+5,d);
for(int j=0;j<15;j++)
cout<<" "<<d[j];
cin.get();
return 0;
}
sort()的原型是：
template <class RandomAccessIterator>
void sort(RandomAccessIterator first, RandomAccessIterator last);
功能是對[first,last-1]區間內的元素進行排序操作。與之類似的操作還有：partial_sort(), stable_sort()，partial_sort_copy()等等。 merge()的原型是：
template <class InputIterator1, class InputIterator2, class OutputIterator>
OutputIterator merge(InputIterator1 first1, InputIterator1 last1,\
InputIterator2 first2, InputIterator2 last2,OutputIterator result);
將有序區間[first1,last1-1]和[first2,last2-1]合並到[result, result + (last1 - first1) + (last2 - first2)-1]區間內。
Includes()的原型是：
template <class InputIterator1, class InputIterator2>
bool includes(InputIterator1 first1, InputIterator1 last1,\
InputIterator2 first2, InputIterator2 last2);
其功能是檢查有序區間[first2,last2-1]內元素是否都在[first1,last1-1]區間內，返回一個bool值。
通用數值算法（generalized numeric algorithms）
這一類算法還不多，涉及到專業領域中有用的算術操作，獨立包涵於頭文件<numeric>中（HP版本的STL中是<algo.h>）。這裡不作介紹。
STL中的算法大都有多種版本，常見的版本有以下4中：
默認版本，假設給出了特定操作符；
一般版本，使用了成員提供的操作符；
復制版本，對原隊列的副本進行操作，常帶有 _copy 後綴；
謂詞版本，只應用於滿足給定謂詞的隊列成員，常帶有 _if 後綴；
以上我們學習了STL容器和算法的概念，以及一些簡單的STL容器和算法。在使用算法處理容器內的數據時，需要從一個數據成員移向另一個數據成員，迭代器恰好實現了這一功能。下面我們來學習STL迭代器 。
迭代器（itertor）：#include<iterator>
迭代器實際上是一種泛化指針，如果一個迭代器指向了容器中的某一成員，那麼迭代器將可以通過自增自減來遍歷容器中的所有成員。迭代器是聯系容器和算法的媒介，是算法操作容器的接口。在運用算法操作容器的時候，我們常常在不知不覺中已經使用了迭代器。
STL中定義了6種迭代器：
輸入迭代器，在容器的連續區間內向前移動，可以讀取容器內任意值；
輸出迭代器，把值寫進它所指向的隊列成員中；
前向迭代器，讀取隊列中的值，並可以向前移動到下一位置（++p,p++）；
雙向迭代器，讀取隊列中的值，並可以向前向後遍歷容器；
隨機訪問迭代器, vector<T>::iterator，list<T>::iterator等都是這種迭代器 ；
流迭代器，可以直接輸出、輸入流中的值；
實際上，在前面的例子中，我們不停的在用迭代器。下面我們用幾個例子來幫助理解這些迭代器的用法。
下面的例子用到了輸入輸出迭代器：
// stl_cpp_17.cpp
#include <iostream>
#include <fstream>
#include <iterator>
#include <vector>
#include <string>
using namespace std;
int main(void)
{
vector<string> v1;
ifstream file("Text1.txt");
if(file.fail())
{
cout<<"open file Text1.txt failed"<<endl;
return 1;
}
copy(istream_iterator<string>(file),istream_iterator<string>(),inserter(v1,\
v1.begin()));
copy(v1.begin(),v1.end(),ostream_iterator<string>(cout," "));
cout<<endl;
cin.get();
return 0;
}
這裡用到了輸入迭代器istream_iterator，輸出迭代器ostream_iterator。程序完成了將一個文件輸出到屏幕的功能，先將文件讀入，然後通過輸入迭代器把文件內容復制到類型為字符串的向量容器內，最後由輸出迭代器輸出。Inserter是一個輸入迭代器的一個函數(迭代器適配器)，它的使用方法是：
inserter (container ,pos);
congtainer是將要用來存入數據的容器，pos是容器存入數據的開始位置。上例中，是把文件內容存入（copy()）到向量v1中。
現在我們已經對STL的三大基本組件有了一個大概的了解，下面讓我們一起來看看STL的其他標准組件。
函數對象（functor或者funtion objects）：#include <function>
函數對象又稱之為仿函數。函數對象將函數封裝在一個對象中，使得它可作為參數傳遞給合適的STL算法，從而使算法的功能得以擴展。可以把它當作函數來使用。用戶也可以定義自己的函數對象。下面讓我們來定義一個自己的函數對象。
// stl_cpp_18.cpp
#include <iostream>
using namespace std;
struct int_max{
int operator()(int x,int y){return x>y?x:y; }
};//operator() 重載了"（）"， (int x,int y)是參數列表
int main(void)
{
cout<<int_max()(3,4)<<endl;
cin.get();
return 0;
}
這裡的int_max（）就是一個函數對象，struct關鍵字也可以用class來代替，只不過struct默認情況下是公有訪問權限，而class定義的是默認私有訪問權限。下面我們來定義一個STL風格的函數對象：
// stl_cpp_19.cpp
#include <iostream>
#include <vector>
using namespace std;
struct adder : public unary_function<double, void>
{
adder() : sum(0) {}
double sum;
void operator()(double x) { sum += x; }
};
int main(void)
{
double a[5]={0.5644,1.1,6.6,8.8,9.9};
vector<double> V(a,a+5);
adder result = for_each(V.begin(), V.end(), adder());
cout << "The sum is " << result.sum << endl;
cin.get();
return 0;
}
在這裡，我們定義了一個函數對象adder()，這也是一個類，它的基類是unary_function函數對象。unary_function是一個空基類，不包涵任何操作或變量。只是一種格式說明，它有兩個參數，第一個參數是函數對象的使用數據類型，第二個參數是它的返回類型。基於它所定義的函數對象是一元函數對象。（注：用關鍵字struct或者class定義的類型實際上都是"類"）
STL內定義了各種函數對象，否定器、約束器、一元謂詞、二元謂詞都是常用的函數對象。函數對象對於編程來說很重要，因為他如同對象類型的抽象一樣作用於操作。
適配器（adapter）：
適配器是用來修改其他組件接口的STL組件，是帶有一個參數的類模板（這個參數是操作的值的數據類型）。STL定義了3種形式的適配器：容器適配器，迭代器適配器，函數適配器。
容器適配器：包括棧（stack）、隊列(queue)、優先(priority_queue)。使用容器適配器，stack就可以被實現為基本容器類型（vector,dequeue,list）的適配。可以把stack看作是某種特殊的vctor,deque或者list容器，只是其操作仍然受到stack本身屬性的限制。queue和priority_queue與之類似。容器適配器的接口更為簡單，只是受限比一般容器要多；
迭代器適配器：修改為某些基本容器定義的迭代器的接口的一種STL組件。反向迭代器和插入迭代器都屬於迭代器適配器，迭代器適配器擴展了迭代器的功能；
函數適配器：通過轉換或者修改其他函數對象使其功能得到擴展。這一類適配器有否定器（相當於"非"操作）、幫定器、函數指針適配器。
結束語
如果你理解了算法、迭代器、容器，那麼你幾乎就了解了 STL。關於STL的其他方面，新手都是不常用的，可以暫時以理解STL的組成的編程思想為主。這篇文章裡用到了19個cpp代碼，每個代碼都在Windows 2000+ Dev-C++ 4.9.9.0和windows 2000＋VC環境下通過編譯運行。讀者可以通過copy/paste到任何一款C++編譯器中運行。無論你想不想學STL，先運行一下STL代碼吧。編程快樂，好好學習，天天向上。
我是新手，歡迎高手批評，歡迎STL學習者交流： Email：[email protected] QQ:370679790
【附錄】
附錄一：Dev-C++ 和VC
在Dev-C++ 4.9.9.0 +windows 2000下，不允許出現,void main(){} 而必須為 int main() {return 0;} ,或者 int main(){},奇怪的是VC對 int main(){} 的寫法會提出警告，而必須為 int main() {return 0;}。建議使用標准格式 int main(void) {……return 0;}
Dev-C++而且不支持頭文件方式，#include <iostream.h>是不對的，而必須為#include <iostream> using namespace std; VC兩種格式都支持。建議使用#include <iostream> using namespace std;
如果用純C/C++編程，建議使用比較簡單的C++編譯器，甚至是命令行下的編譯方式。功能強大的IDE甚至會誤導編程者。還要花費不少的時間來學習使用IDE開發環境。Dev比VC要簡單一些，只是不適合做大型工程，而且編譯時間比VC稍慢一點，純C++編程建議使用。他有插入時間和頭文件注釋模板的功能，作者可以方便地插入編程、程序更改時間，方便地填寫程序說明信息。
在Dev下可以導入VC工程，而且保持原來的VC工程文件，但是Dev對VC的支持還不夠，在編譯的時候會遇到錯誤。
在編寫dos程序的時候，建議在程序的末尾return之前加上：getchar();cin.get();之類的代碼，以方便看運行結果。
附錄二：中小型程序段的編輯工具
在編輯程序過程中並不一定非要在特定的IDE環境中，在有些專業化的文本編輯工具中編輯代碼會更有利於代碼的修改和編輯。這裡介紹幾種更能比較強大的文本編輯器。
UltraEdit-32；
EditPlus；
SourceInsight；
Vim；
這後面是寫給Jerry的，你個垃圾別說不看哦。據說你有很多領帶，想找你要幾個來，我有西裝了，還沒有領帶呢。嘎嘎。算了，你又都還給別人了，我靠，我損失了一個領帶。
門戶無聲無息地由內而外一扇扇緩緩開啟，在通往神殿的深處、有依稀的光芒！腳下的東西，已經令我踉跄不已，但是我仍然向前走去，我要找到光芒之門。我要找到光芒之門。我一層一層的下行，在神殿的最低層，我找到了那所謂的……光明之門!——暗黑破壞神Ⅱ
今天，我出門的時候聽見青蛙叫了，呱呱～～
宿捨前後的花花草草都抽新綠了，不知道你個聊天大忙人注意到了沒有。
現在5點多了，我餓了，吃點東西去。
你還記得吧：朋友、知己、愛人，三者得其一則死而無憾
你是我的什麼呢？嘎嘎。那個死老貓說什麼來著？
剛剛租給我房子的老板過來聊天，他看到我在學習日語，便說起了日語，日語的重要性，他說，沒學習日語的話，他就沒有工作了，知道我是搞計算機的，他還說CAD的制圖高手月薪達到7000以上，呵呵，不知道該怎麼說了，4年的時間就學會了怎麼自己折騰自己，怎麼使壞了……
23歲，這女人荒的日子怎麼過呀。媽媽的。
搞笑的是，我今天第一次聽到了《共產兒童團歌》，呵呵，Jerry你聽過麼？？嘎嘎
今天，買了一個新的打火機，所以為了對得起這新打火機，我就一直在這裡抽煙
為什麼心中有如此多得憤懑，為什麼會還會因此而憤世嫉俗地尖銳。
2005年4月14日星期四，今天，我編譯了我的第一個java程序：
//My.java
public class My
{ public static void main(String [] args)
{
System.out.println("Hi,laji");
}
}
呵呵，祝賀一下，我開始學習java了早上5：01 新的一天開始了
4/16/2005 1:39:06 AM
剛才，我在我的linux下掛上了我的windows盤，不過沒有輔助軟件的情況下只能掛fat格式的磁盤，可惜我的全部都是ntfs格式的，結果，我把一個硬盤分區的20G內容全部倒出來，在windows下格式化成fat32格式的。
#fdisk -l
#mfdir /mnt/win
#mount -t vfat -o iocharset=cp936 /dev/hda9 /mnt/win
結果仍然有些文件不能打開，郁悶
我試了 iocharset＝utf8 和 iocharset＝gb2312中文顯示都不是很理想，仍然有很多的txt文檔打不開，我哭……
然後，我在linux下用文本編輯器寫了一個簡單的cpp文件：
#g++ -o hello -t hello.cpp
I love you ,Linux!
呵呵，挺有意思的。
在linux的IDE環境下打開windows裡的pdf文件和ppt文件，顯示效果不太好，很多中文都顯示不了，氣死鳥，等過兩天，下個補丁裝上回來再說。
在linux下裝了幾個簡單的程序：
#sh xxx.sh
或者
#sh xxxx
安裝開始，呵呵，有意思吧？
這篇文章已經拖了很長時間了，我常常是一邊開著2個C++編譯器，一個文本編輯器，不時的查書，看電子文檔，英文的，中文的，翻譯的……
總算差不多了，還寫一點簡單的東西就結束它吧，累了
我想玩linux了,Java也不錯啊
今天中午，老貓跟我說，他現在可郁悶了，哎呀，在單位看到的都是陰暗面
有點迷茫……這只可憐的貓，剛剛工作還沒有適應過來呢
我想起來去年的這個時候，雪兒也是剛剛工作，也是心情郁悶
上帝保佑老百姓！
every time I boot Linux ,if I want to use windows files i have to mount the system files to linux.
Web docs tells that ,there are to ways to mount the windows file system to linux only once:
one is:
edit: /etc/auto.master
get the line: # /misc /etc/auto.misc --time out=60 and delete the "#"
then edit: /etc/auto.misc
add: d -fstype=auto,iocharset=cp936 :/dev/hda9
but this dons`t work,I rbooted my pc 3 times ,no use!
Then i have to try the second way:
edit: ect/fstab
add: /dev/hda9 /mnt/win/ vfat defaults,iocharset=cp936,codepage=936 0 0
i did this and reboot my linux,this time it works!gaga
中文顯示還是個問題,現在我輸入的這短話,是我在linux輸入的，但是我看不見我輸入的文字，全部都是方塊，這個問題我還是沒有解決，真是遺憾啊。免費的東西嘛，自己總要付出點代價嘛，喔？呵呵Jerry turns left,Tom right!
好了，這個問題解決了，要用ARPL aitiM BG字體才可以，其它的字體要麼不能顯示中文，要麼只能顯示一部分中文，呵呵呵呵
呵呵，我餓了，13:08我該吃飯去了，媽媽的，女人荒——4/17/05 13:10:14
linux下安裝文件有時候需要全部編譯代碼：
./configure
make
su
make install
ldcofig
exit
挺有意思的，這不比Windows差呀，免費的哦，只是暫時還不能播放視頻，我要裝軟件才行，真麻煩啊
ntfs的盤可以掛上去了，但是只能讀取系統文件，個人文件看不見，還不能往裡寫東西：
usb掛上去了，插上去就有反應；
u盤是/mnt/sda1自動建的文件夾；
移動硬盤是/mnt/sda5；
可以讀寫
txt格式的還只能讀寫ANSI的unicode格式的打不開。
java的編譯工具jdk－for-linux安裝成功，linux的環境變量文件：
/etc/profile 修改後重啟即可了
運行java,javac命令，OK！呵呵，牛吧
附錄我不想寫了，就這樣吧，下午寫上參考書籍目錄就發到網上去吧，呵呵
還有就是把這個也發到我的博客頁面上。
