在 C++ 中需要自己來處理內存，稍微處理不當，就會存在非常郁悶的內存泄漏問題

還好，現在 C++ 中推出了強大的智能指針，即 smart_ptr ，本文先稍微介紹一下 smart_ptr ，然后具體說說 shared_ptr 和 weak_ptr ，特別是 enable_shared_from_this 和 shared_from_this

除了標準庫中的 auto_ptr 之外

在 boost 或者 tr1 中的 smart_ptr 主要是有下面幾種

• scoped_ptr
• scoped_array
• shared_ptr
• shared_array
• intrusive_ptr
• weak_ptr

這些里面最難理解的是綜合應用了 weak_ptr 和 shared_ptr 的 enable_shared_from_this 類，在該類中定了成員函數 shared_from_this() ，返回 shared_ptr<T> 。這個函數僅在 shared_ptr<T> 的構造函數被調用之后才能使用。原因是 enable_shared_from_this::weak_ptr 并不在構造函數中設置（此處的構造函數指的是類型 T 的構造函數），而是在 shared_ptr<T> 的構造函數中設置（此處的構造函數指的是類型 shared_ptr<T> 的構造函數）。

在下面的代碼中：

#include <iostream> #include <string> #include <boost/shared_ptr.hpp> #include <boost/weak_ptr.hpp> #include <boost/enable_shared_from_this.hpp> using namespace std; struct Ansible : public boost::enable_shared_from_this<Ansible> { boost::shared_ptr<Ansible> get_shared() { boost::shared_ptr<Ansible> r(this); return r; } ~Ansible() { cout<<"Destructor"<<endl; } }; int main(int argc,char* argv[]) { boost::shared_ptr<Ansible> a(new Ansible); Ansible& r = *a; //boost::shared_ptr<Ansible> b = r.get_shared(); boost::shared_ptr<Ansible> b = r.shared_from_this(); cout<<"Reference Number "<<a.use_count()<<" "<<b.use_count()<<endl; return 0; }

若不使用 shared_from_this() 成員函數，則會輸出 a 和 b 的 use_count() 都為 1 ，然后調用 2 次類型 Ansible 的析構函數，若添加了該成員函數，在 a 和 b 的 use_count() 輸出為 2 ，只是調用一次 Ansible 的析構函數。原因是 enable_shared_from_this 里面在 shared_ptr<T> 的時候構造了一個 weak_ptr 類，而 weak_ptr 只是監視，不增加引用計數

（下面是轉載： http://huyuguang1976.spaces.live.com/blog/cns!2A9E272E3C33AFF1!185.entry ）

所以如下代碼是錯誤的：

class D:public boost::enable_shared_from_this<D>

{

public:

    D()

    {

        boost::shared_ptr<D> p=shared_from_this();

    }

};

原因很簡單，在 D 的構造函數中雖然可以保證 enable_shared_from_this<D> 的構造函數已經被調用，但正如前面所說， weak_ptr 還沒有設置。

如下代碼也是錯誤的：

class D:public boost::enable_shared_from_this<D>

{

public:

    void func()

    {

        boost::shared_ptr<D> p=shared_from_this();

    }

};

void main()

{

    D d;

    d.func();

}

錯誤原因同上。

如下代碼是正確的：

void main()

{

    boost::shared_ptr<D> d(new D);

    d->func();

}

這里 boost::shared_ptr<D> d(new D) 實際上執行了 3 個動作：首先調用 enable_shared_from_this<D> 的構造函數；其次調用 D 的構造函數；最后調用 shared_ptr<D> 的構造函數。是第 3 個動作設置了 enable_shared_from_this<D> 的 weak_ptr ，而不是第 1 個動作。這個地方是很違背 c++ 常理和邏輯的，必須小心。

結論是，不要在構造函數中使用 shared_from_this ；其次，如果要使用 shared_ptr ，則應該在所有地方均使用，不能使用 D d 這種方式，也決不要傳遞裸指針。


另解：：：：：
struct X

{

         boost::shared_ptr<X> getX()

{

         boost::shared_ptr<X> r ;//????如何實現

         return r;

}

};

要得到X的智能指針,只是在對象指針是受shared_ptr保護的基礎上的,舉例如下:

void test_X()

{

         {

X x;

                  boost::shared_ptr<X> px = x.getX();//錯誤

}

         {

X* x = new X();

boost::shared_ptr<X> px = x->getX();//錯誤

}

         {

boost::shared_ptr<X>  x (new X());

boost::shared_ptr<X> px = x->getX();//正確

}

}

string類的構造函數：
string(const char *s);    //用c字符串s初始化
string(int n,char c);     //用n個字符c初始化
此外，string類還支持默認構造函數和復制構造函數，如string s1；string s2="hello"；都是正確的寫法。當構造的string太長而無法表達時會拋出length_error異常

string類的字符操作：
const char &operator[](int n)const;
const char &at(int n)const;
char &operator[](int n);
char &at(int n);
operator[]和at()均返回當前字符串中第n個字符的位置，但at函數提供范圍檢查，當越界時會拋出out_of_range異常，下標運算符[]不提供檢查訪問。
const char *data()const;//返回一個非null終止的c字符數組
const char *c_str()const;//返回一個以null終止的c字符串
int copy(char *s, int n, int pos = 0) const;//把當前串中以pos開始的n個字符拷貝到以s為起始位置的字符數組中，返回實際拷貝的數目

string的特性描述:
int capacity()const;    //返回當前容量（即string中不必增加內存即可存放的元素個數）
int max_size()const;    //返回string對象中可存放的最大字符串的長度
int size()const;        //返回當前字符串的大小
int length()const;       //返回當前字符串的長度
bool empty()const;        //當前字符串是否為空
void resize(int len,char c);//把字符串當前大小置為len，并用字符c填充不足的部分

string類的輸入輸出操作:
string類重載運算符operator>>用于輸入，同樣重載運算符operator<<用于輸出操作。
函數getline(istream &in,string &s);用于從輸入流in中讀取字符串到s中，以換行符'\n'分開。

string的賦值：
string &operator=(const string &s);//把字符串s賦給當前字符串
string &assign(const char *s);//用c類型字符串s賦值
string &assign(const char *s,int n);//用c字符串s開始的n個字符賦值
string &assign(const string &s);//把字符串s賦給當前字符串
string &assign(int n,char c);//用n個字符c賦值給當前字符串
string &assign(const string &s,int start,int n);//把字符串s中從start開始的n個字符賦給當前字符串
string &assign(const_iterator first,const_itertor last);//把first和last迭代器之間的部分賦給字符串

string的連接：
string &operator+=(const string &s);//把字符串s連接到當前字符串的結尾 
string &append(const char *s);            //把c類型字符串s連接到當前字符串結尾
string &append(const char *s,int n);//把c類型字符串s的前n個字符連接到當前字符串結尾
string &append(const string &s);    //同operator+=()
string &append(const string &s,int pos,int n);//把字符串s中從pos開始的n個字符連接到當前字符串的結尾
string &append(int n,char c);        //在當前字符串結尾添加n個字符c
string &append(const_iterator first,const_iterator last);//把迭代器first和last之間的部分連接到當前字符串的結尾 

string的比較：
bool operator==(const string &s1,const string &s2)const;//比較兩個字符串是否相等
運算符">","<",">=","<=","!="均被重載用于字符串的比較；
int compare(const string &s) const;//比較當前字符串和s的大小
int compare(int pos, int n,const string &s)const;//比較當前字符串從pos開始的n個字符組成的字符串與s的大小
int compare(int pos, int n,const string &s,int pos2,int n2)const;//比較當前字符串從pos開始的n個字符組成的字符串與s中pos2開始的n2個字符組成的字符串的大小
int compare(const char *s) const;
int compare(int pos, int n,const char *s) const;
int compare(int pos, int n,const char *s, int pos2) const;
compare函數在>時返回1，<時返回-1，==時返回0  

string的子串：
string substr(int pos = 0,int n = npos) const;//返回pos開始的n個字符組成的字符串


string的交換：
void swap(string &s2);    //交換當前字符串與s2的值

string類的查找函數：

int find(char c, int pos = 0) const;//從pos開始查找字符c在當前字符串的位置
int find(const char *s, int pos = 0) const;//從pos開始查找字符串s在當前串中的位置
int find(const char *s, int pos, int n) const;//從pos開始查找字符串s中前n個字符在當前串中的位置
int find(const string &s, int pos = 0) const;//從pos開始查找字符串s在當前串中的位置
//查找成功時返回所在位置，失敗返回string::npos的值

int rfind(char c, int pos = npos) const;//從pos開始從后向前查找字符c在當前串中的位置
int rfind(const char *s, int pos = npos) const;
int rfind(const char *s, int pos, int n = npos) const;
int rfind(const string &s,int pos = npos) const;
//從pos開始從后向前查找字符串s中前n個字符組成的字符串在當前串中的位置，成功返回所在位置，失敗時返回string::npos的值

int find_first_of(char c, int pos = 0) const;//從pos開始查找字符c第一次出現的位置
int find_first_of(const char *s, int pos = 0) const;
int find_first_of(const char *s, int pos, int n) const;
int find_first_of(const string &s,int pos = 0) const;
//從pos開始查找當前串中第一個在s的前n個字符組成的數組里的字符的位置。查找失敗返回string::npos

int find_first_not_of(char c, int pos = 0) const;
int find_first_not_of(const char *s, int pos = 0) const;
int find_first_not_of(const char *s, int pos,int n) const;
int find_first_not_of(const string &s,int pos = 0) const;
//從當前串中查找第一個不在串s中的字符出現的位置，失敗返回string::npos

int find_last_of(char c, int pos = npos) const;
int find_last_of(const char *s, int pos = npos) const;
int find_last_of(const char *s, int pos, int n = npos) const;
int find_last_of(const string &s,int pos = npos) const;

int find_last_not_of(char c, int pos = npos) const;
int find_last_not_of(const char *s, int pos = npos) const;
int find_last_not_of(const char *s, int pos, int n) const;
int find_last_not_of(const string &s,int pos = npos) const;
//find_last_of和find_last_not_of與find_first_of和find_first_not_of相似，只不過是從后向前查找

string類的替換函數：

string &replace(int p0, int n0,const char *s);//刪除從p0開始的n0個字符，然后在p0處插入串s
string &replace(int p0, int n0,const char *s, int n);//刪除p0開始的n0個字符，然后在p0處插入字符串s的前n個字符
string &replace(int p0, int n0,const string &s);//刪除從p0開始的n0個字符，然后在p0處插入串s
string &replace(int p0, int n0,const string &s, int pos, int n);//刪除p0開始的n0個字符，然后在p0處插入串s中從pos開始的n個字符
string &replace(int p0, int n0,int n, char c);//刪除p0開始的n0個字符，然后在p0處插入n個字符c
string &replace(iterator first0, iterator last0,const char *s);//把[first0，last0）之間的部分替換為字符串s
string &replace(iterator first0, iterator last0,const char *s, int n);//把[first0，last0）之間的部分替換為s的前n個字符
string &replace(iterator first0, iterator last0,const string &s);//把[first0，last0）之間的部分替換為串s
string &replace(iterator first0, iterator last0,int n, char c);//把[first0，last0）之間的部分替換為n個字符c
string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0，last0）之間的部分替換成[first，last）之間的字符串

string類的插入函數：

string &insert(int p0, const char *s);
string &insert(int p0, const char *s, int n);
string &insert(int p0,const string &s);
string &insert(int p0,const string &s, int pos, int n);
//前4個函數在p0位置插入字符串s中pos開始的前n個字符
string &insert(int p0, int n, char c);//此函數在p0處插入n個字符c
iterator insert(iterator it, char c);//在it處插入字符c，返回插入后迭代器的位置
void insert(iterator it, const_iterator first, const_iterator last);//在it處插入[first，last）之間的字符
void insert(iterator it, int n, char c);//在it處插入n個字符c

string類的刪除函數

iterator erase(iterator first, iterator last);//刪除[first，last）之間的所有字符，返回刪除后迭代器的位置
iterator erase(iterator it);//刪除it指向的字符，返回刪除后迭代器的位置
string &erase(int pos = 0, int n = npos);//刪除pos開始的n個字符，返回修改后的字符串

string類的迭代器處理：

string類提供了向前和向后遍歷的迭代器iterator，迭代器提供了訪問各個字符的語法，類似于指針操作，迭代器不檢查范圍。
用string::iterator或string::const_iterator聲明迭代器變量，const_iterator不允許改變迭代的內容。常用迭代器函數有：
const_iterator begin()const;
iterator begin();                //返回string的起始位置
const_iterator end()const;
iterator end();                    //返回string的最后一個字符后面的位置
const_iterator rbegin()const;
iterator rbegin();                //返回string的最后一個字符的位置
const_iterator rend()const;
iterator rend();                    //返回string第一個字符位置的前面
rbegin和rend用于從后向前的迭代訪問，通過設置迭代器string::reverse_iterator,string::const_reverse_iterator實現

字符串流處理：

通過定義ostringstream和istringstream變量實現，<sstream>頭文件中
例如：
    string input("hello,this is a test");
    istringstream is(input);
    string s1,s2,s3,s4;
    is>>s1>>s2>>s3>>s4;//s1="hello,this",s2="is",s3="a",s4="test"
    ostringstream os;
    os<<s1<<s2<<s3<<s4;
    cout<<os.str();

1. 文本模式(textmode)和二進制模式(binarymode)的區別

0.  無論你用哪種語言進行程序設計，也無論你用哪個函數進行文件操作（庫函數也好，直接操作系統API也好），最終的文件打開的操作都是由操作系統來進行的，因此各種語言的情況從本質上來說都是相同的。用二進制模式打開一個文件的時候，文件本身的內容和你編寫程序時用函數讀到的內容完全相同（或者說和磁盤上的內容完全相同）。但是如果用了文本模式，那么操作系統在將文件內容傳給上層程序（庫函數，或者是你的程序）時，或者上層程序通過操作系統向文件寫入內容時，操作系統都會預先進行一層預處理（或者說轉義），具體過程依賴于操作系統的實現。

1.  在unix（包括linux）系統上，一個程序從文件里讀數據，它得到的數據就是數據本身，一個一個的字節。然而在windows系統上，一個文件可以 用兩種模式打開，二進制模式或者文本模式，在二進制模式下，表現的就像unix系統；然而在文本模式下，會有一個轉換。是\n <-------> \r\n之間的轉換。具體講就是將回車符"\r\n"解釋成"\n"（讀出時），將"\n"解釋成"\r\n"（寫入時）。總之，在unix系統上，打開文件只有二進制模式，在windows系統上，打開文件有文本模式和二進制模式兩種。

2.文本文件與二進制文件的區別:

最普通的情況，是為出現在where子句的字段建一個索引。為方便講述，我們先建立一個如下的表。
CREATE TABLE mytable (
　id serial primary key,
　category_id int not null default 0,
　user_id int not null default 0,
　adddate int not null default 0
);
如果你在查詢時常用類似以下的語句：
　SELECT * FROM mytable WHERE category_id=1;
最直接的應對之道，是為category_id建立一個簡單的索引：
　CREATE INDEX mytable_categoryid
　ON mytable (category_id);
OK.如果你有不止一個選擇條件呢？例如：
　SELECT * FROM mytable WHERE category_id=1 AND user_id=2;
你的第一反應可能是，再給user_id建立一個索引。不好，這不是一個最佳的方法。你可以建立多重的索引。
CREATE INDEX mytable_categoryid_userid ON mytable (category_id,user_id);
注意到我在命名時的習慣了嗎？我使用"表名_字段1名_字段2名"的方式。你很快就會知道我為什么這樣做了。
現在你已經為適當的字段建立了索引，不過，還是有點不放心吧，你可能會問，數據庫會真正用到這些索引嗎？測試一下就OK，對于大多數的數據庫來說，這是很容易的，只要使用EXPLAIN命令：
EXPLAIN
　SELECT * FROM mytable
WHERE category_id=1 AND user_id=2;
　This is what Postgres 7.1 returns (exactly as I expected)
　NOTICE: QUERY PLAN:
　Index Scan using mytable_categoryid_userid on
　mytable (cost=0.00..2.02 rows=1 width=16)
EXPLAIN
以上是postgres的數據，可以看到該數據庫在查詢的時候使用了一個索引（一個好開始），而且它使用的是我創建的第二個索引。看到我上面命名的好處了吧，你馬上知道它使用適當的索引了。

接著，來個稍微復雜一點的，如果有個ORDER BY字句呢？不管你信不信，大多數的數據庫在使用order by的時候，都將會從索引中受益。
　SELECT * FROM mytable
WHERE category_id=1 AND user_id=2
　ORDER BY adddate DESC;

很簡單，就象為where字句中的字段建立一個索引一樣，也為ORDER BY的字句中的字段建立一個索引：
　CREATE INDEX mytable_categoryid_userid_adddate
　ON mytable (category_id,user_id,adddate);
　注意: "mytable_categoryid_userid_adddate" 將會被截短為
"mytable_categoryid_userid_addda"
　CREATE
　EXPLAIN SELECT * FROM mytable
WHERE category_id=1 AND user_id=2
　ORDER BY adddate DESC;
　NOTICE: QUERY PLAN:
　Sort (cost=2.03..2.03 rows=1 width=16)
-> Index Scan using mytable_categoryid_userid_addda
　on mytable (cost=0.00..2.02 rows=1 width=16)
　EXPLAIN
看看EXPLAIN的輸出，數據庫多做了一個我們沒有要求的排序，這下知道性能如何受損了吧，看來我們對于數據庫的自身運作是有點過于樂觀了，那么，給數據庫多一點提示吧。
為 了跳過排序這一步，我們并不需要其它另外的索引，只要將查詢語句稍微改一下。這里用的是postgres，我們將給該數據庫一個額外的提示--在 ORDER BY語句中，加入where語句中的字段。這只是一個技術上的處理，并不是必須的，因為實際上在另外兩個字段上，并不會有任何的排序操作，不過如果加 入，postgres將會知道哪些是它應該做的。
　EXPLAIN SELECT * FROM mytable
WHERE category_id=1 AND user_id=2
　ORDER BY category_id DESC,user_id DESC,adddate DESC;
　NOTICE: QUERY PLAN:
　Index Scan Backward using
mytable_categoryid_userid_addda on mytable
　(cost=0.00..2.02 rows=1 width=16)
　EXPLAIN
現在使用我們料想的索引了，而且它還挺聰明，知道可以從索引后面開始讀，從而避免了任何的排序。
以 上說得細了一點，不過如果你的數據庫非常巨大，并且每日的頁面請求達上百萬算，我想你會獲益良多的。不過，如果你要做更為復雜的查詢呢，例如將多張表結合 起來查詢，特別是where限制字句中的字段是來自不止一個表格時，應該怎樣處理呢？我通常都盡量避免這種做法，因為這樣數據庫要將各個表中的東西都結合 起來，然后再排除那些不合適的行，搞不好開銷會很大。
如果不能避免，你應該查看每張要結合起來的表，并且使用以上的策略來建立索引，然后再用EXPLAIN命令驗證一下是否使用了你料想中的索引。如果是的話，就OK。不是的話，你可能要建立臨時的表來將他們結合在一起，并且使用適當的索引。
要注意的是，建立太多的索引將會影響更新和插入的速度，因為它需要同樣更新每個索引文件。對于一個經常需要更新和插入的表格，就沒有必要為一個很少使用的where字句單獨建立索引了，對于比較小的表，排序的開銷不會很大，也沒有必要建立另外的索引。
以 上介紹的只是一些十分基本的東西，其實里面的學問也不少，單憑EXPLAIN我們是不能判定該方法是否就是最優化的，每個數據庫都有自己的一些優化器，雖 然可能還不太完善，但是它們都會在查詢時對比過哪種方式較快，在某些情況下，建立索引的話也未必會快，例如索引放在一個不連續的存儲空間時，這會增加讀磁 盤的負擔，因此，哪個是最優，應該通過實際的使用環境來檢驗。
在剛開始的時候，如果表不大，沒有必要作索引，我的意見是在需要的時候才作索引，也可用一些命令來優化表，例如MySQL可用"OPTIMIZE TABLE"。
綜上所述，在如何為數據庫建立恰當的索引方面，你應該有一些基本的概念了。

索引

使用索引可快速訪問數據庫表中的特定信息。索引是對數據庫表中一列或多列的值進行排序的一種結構，例如 employee 表的姓（lname）列。如果要按姓查找特定職員，與必須搜索表中的所有行相比，索引會幫助您更快地獲得該信息。

索引提供指向存儲在表的指定列中的數據值的指針，然后根據您指定的排序順序對這些指針排序。數據庫使用索引的方式與您使用書籍中的索引的方式很相似：它搜索索引以找到特定值，然后順指針找到包含該值的行。

在數據庫關系圖中，您可以在選定表的“索引/鍵”屬性頁中創建、編輯或刪除每個索引類型。當保存索引所附加到的表，或保存該表所在的關系圖時，索引將保存在數據庫中。有關詳細信息，請參見創建索引。

作為通用規則，只有當經常查詢索引列中的數據時，才需要在表上創建索引。索引占用磁盤空間，并且降低添加、刪除和更新行的速度。在多數情況下，索引用于數據檢索的速度優勢大大超過它的。

可以基于數據庫表中的單列或多列創建索引。多列索引使您可以區分其中一列可能有相同值的行。

如果經常同時搜索兩列或多列或按兩列或多列排序時，索引也很有幫助。例如，如果經常在同一查詢中為姓和名兩列設置判據，那么在這兩列上創建多列索引將很有意義。

確定索引的有效性：

• 檢查查詢的 WHERE 和 JOIN 子句。在任一子句中包括的每一列都是索引可以選擇的對象。
• 對新索引進行試驗以檢查它對運行查詢性能的影響。
• 考慮已在表上創建的索引數量。最好避免在單個表上有很多索引。
• 檢查已在表上創建的索引的定義。最好避免包含共享列的重疊索引。
• 檢查某列中唯一數據值的數量，并將該數量與表中的行數進行比較。比較的結果就是該列的可選擇性，這有助于確定該列是否適合建立索引，如果適合，確定索引的類型。

根據數據庫的功能，可以在數據庫設計器中創建三種索引：唯一索引、主鍵索引和聚集索引。有關數據庫所支持的索引功能的詳細信息，請參見數據庫文檔。

唯一索引

唯一索引是不允許其中任何兩行具有相同索引值的索引。

當現有數據中存在重復的鍵值時，大多數數據庫不允許將新創建的唯一索引與表一起保存。數據庫還可能防止添加將在表中創建重復鍵值的新數據。例如，如果在 employee 表中職員的姓 (lname) 上創建了唯一索引，則任何兩個員工都不能同姓。

主鍵索引

數據庫表經常有一列或列組合，其值唯一標識表中的每一行。該列稱為表的主鍵。

在數據庫關系圖中為表定義主鍵將自動創建主鍵索引，主鍵索引是唯一索引的特定類型。該索引要求主鍵中的每個值都唯一。當在查詢中使用主鍵索引時，它還允許對數據的快速訪問。

聚集索引

在聚集索引中，表中行的物理順序與鍵值的邏輯（索引）順序相同。一個表只能包含一個聚集索引。

如果某索引不是聚集索引，則表中行的物理順序與鍵值的邏輯順序不匹配。與非聚集索引相比，聚集索引通常提供更快的數據訪問速度。

--數組元素插入有兩種方式
mydb=> insert into test_array(phone) values ('{1,2}');
INSERT 0 1
mydb=> insert into test_array(phone) values ('{2,3}');
INSERT 0 1

mydb=> insert into test_array(phone) values (array[3,4,5]);
INSERT 0 1

mydb=> select * From test_array;
 id |  phone 
----+---------
  1 | {1,2}
  2 | {2,3}
  3 | {3,4,5}
(3 rows)

--數組元素的引用
mydb=> select phone  from test_array where id=1;
 phone
-------
 {1,2}
(1 row)

mydb=> select phone[1],phone[2]  from test_array where id=1;
 phone | phone
-------+-------
     1 |     2
    
    
    
一 常見的數組操作(Array Operators)

--equal
mydb=>  select array[1,2]=array[1.1,2.1]::int[];
 ?column?
----------
 t
(1 row)

--not equal
mydb=> select array[1,2] <> array[1,2,3];
 ?column?
----------
 t
(1 row)

--less than
mydb=> select ARRAY[1,2,3] < ARRAY[1,2,4];
 ?column?
----------
 t
(1 row)

--greater than
mydb=> select ARRAY[1,4,3] > ARRAY[1,2,4];
 ?column?
----------
 t
(1 row)

--contains
mydb=> select ARRAY[1,4,3] @> ARRAY[3,1];
 ?column?
----------
 t
(1 row)

--is contained by
mydb=> select ARRAY[2,7] <@ ARRAY[1,7,4,2,6];
 ?column?
----------
 t
(1 row)

--overlap (have elements in common)
mydb=> select ARRAY[1,4,3] && ARRAY[2,1];
 ?column?
----------
 t
    

二 常見數組函數( Array Functions )
--將數據元素追加到數組
mydb=> select array_append(array[2,3,4],5);
 array_append
--------------
 {2,3,4,5}
(1 row)

--連接兩個數組
mydb=> select array_cat(array[1,2],array[3,4]);
 array_cat
-----------
 {1,2,3,4}
(1 row)

--獲得數組的維度
mydb=> select array_ndims(array[1,2,3]);
 array_ndims
-------------
           1
(1 row)

mydb=> select array_ndims(array[[1,2,3],[4,5,6]]);
 array_ndims
-------------
           2
(1 row)

--獲得數組的長度                                 ^
mydb=> select array_length(array[1,2,3],1);
 array_length
--------------
            3
(1 row)

mydb=> select array_length(array[[1,2],[2,3]],1);
 array_length
--------------
            2
(1 row)

三 intarray 模塊的數組函數
--獲取元素個數據總和
mydb=> select icount(array[1,2]);
 icount
--------
      2
(1 row)

mydb=> select icount(array[[1,2],[2,3]]);
 icount
--------
      4
(1 row)

--排序
mydb=> select sort_asc(array[4,8,7]);
 sort_asc
----------
 {4,7,8}
(1 row)

mydb=> select sort_desc(array[4,8,7]);
 sort_desc
-----------
 {8,7,4}
(1 row)

mydb=> select sort_desc(array[[4,8,7],[8,9,7]]);
     sort_desc    
-------------------
 {{9,8,8},{7,7,4}}
(1 row)

四 intarray 模塊的數組操作符

--表數據
mydb=> select * from test_array;
 id |  phone 
----+---------
  1 | {1,2}
  2 | {2,3}
  3 | {3,4,5}
  4 | {4,5,6}
  5 | {4,5,7}
(5 rows)

--查找包括相同元素的記錄
mydb=> select id ,phone from test_array where phone && array[1,2]::int8[];
 id | phone
----+-------
  1 | {1,2}
  2 | {2,3}
(2 rows)

--查找數組元素的交集
mydb=> select array[1,2,3] & array[3,4,5];
 ?column?
----------
 {3}
(1 row)