在做ACM題時， 經常都會遇到一些比較大的整數。而常用的內置整數類型常常顯得太小了：其中long和int范圍是[-2^31,2^31)，即-2147483648~2147483647。而unsigned范圍是[0,2^32)，即0~4294967295。也就 是說，常規的32位整數只能夠處理40億以下 的數。 那遇 到比40億要大的數怎么辦呢？這時就要用到C++的64位擴展 了。不同的編譯器對64位整數的擴展有所不同。基于ACM的需 要，下面僅介紹VC6.0與g++編譯器的 擴展。 VC的64位整數 分別叫做__int64與unsigned __int64，其范 圍分別是[-2^63, 2^63)與[0,2^64)，即-9223372036854775808~9223372036854775807與0~18446744073709551615(約1800億億)。對64位整數 的運算與32位整數基本相同，都支持四則運算與位運算等。當進行64位與32位的混 合運算時，32位整數會被隱式轉換成64位整 數。但是，VC的輸入輸出與__int64的兼容 就不是很好了，如果你寫下這樣一段代碼： 1__int64 a; 2cin>>a; 3cout<<a; 那么，在 第2行會收到“error C2679: binary '>>' : no operator defined which takes a right-hand operand of type '__int64' (or there is no acceptable conversion)”的錯 誤；在第3行會收到“error C2593: 'operator <<' is ambiguous”的錯誤。那是不是就不能進行輸入輸出呢？當然不是，你可以使用C的寫 法： scanf("%I64d",&a); printf("%I64d",a); 就可以正確輸入輸出了。當使用unsigned __int64時，把"I64d"改為"I64u"就可以 了。 OJ通常使 用g++編譯器。其64位擴展方 式與VC有所不同，它們分別叫做long long與unsigned long long。處理規 模與除輸入輸出外的使用方法同上。對于輸入輸出，它的擴展比VC好。既可以使用 1long long a; 2cin>>a; 3cout<<a; 也可以使用 scanf("%lld",&a); printf("%lld",a); 使用無符號數時，將"%lld"改成"%llu"即可。 最后我補充一點：作為一個特例，如果你使用的 是Dev-C++的g++編譯器，它使用的是"%I64d"而非"%lld"。
Allocator是C++語言標準庫中最神秘的部分之一。它們很少被顯式使用，標準也沒有明確出它們應該在什么時候被使用。今天的allocator與最初的STL建議非常不同，在此過程中還存在著另外兩個設計－－這兩個都依賴于語言的一些特性，而直到最近才在很少的幾個編譯器上可用。對allocator的功能，標準似乎在一些方面追加了承諾，而在另外一些方面撤銷了承諾。
這篇專欄文章將討論你能用allocator來做什么以及如何定義一個自己的版本。我只會討論C++標準所定義的allocator：引入準標準時代的設計，或試圖繞過有缺陷的編譯器，只會增加混亂。
什么時候不使用Allocator
C++標準中的Allocator分成兩塊：一個通用需求集（描述于§ 20.1.5(表 32)），和叫std::allocator的class（描述于§20.4.1）。如果一個class滿足表32的需求，我們就稱它為一個allocator。std::allocator類滿足那些需求，因此它是一個allocator。它是標準程序庫中的唯一一個預先定義allocator類。
每個 C++程序員都已經知道動態內存分配：寫下new X來分配內存和創建一個X類型的新對象，寫下delete p來銷毀p所指的對象并歸還其內存。你有理由認為allocator會使用new和delete－－但它們沒有。（C++標準將::operator new()描述為“allocation function”，但很奇怪，allocator并不是這樣的。）
有關allocator的最重要的事實是它們只是為了一個目的：封裝STL容器在內存管理上的低層細節。你不應該在自己的代碼中直接調用allocator的成員函數，除非正在寫一個自己的STL容器。你不應該試圖使用allocator來實現operator new[]；這不是allocator該做的。 如果你不確定是否需要使用allocator，那就不要用。
allocator是一個類,有著叫allocate()和deallocate()成員函數（相當于malloc和free）。它還有用于維護所分配的內存的輔助函數和指示如何使用這些內存的typedef（指針或引用類型的名字）。如果一個STL容器使用用戶提供的allocator來分配它所需的所有內存(預定義的STL容器全都能這么做；他們都有一個模板參數，其默認值是std::allocator)，你就能通過提供自己的allocator來控制它的內存管理。
這種柔性是有限制的：仍然由容器自己決定它將要申請多少內存以及如何使用它們。在容器申請更多的內存時，你能控制它調用那個低層函數，但是你不能通過使用allocator來讓一個vector行動起來像一個deque一樣。雖然如此，有時候，這個受限的柔性也很有用。比如，假設你有一個特殊的fast_allocator，能快速分配和釋放內存（也許通過放棄線程安全性，或使用一個小的局部堆），你能通過寫下std::list<T, fast_allocator<T> >而不是簡單的std::list<T>來讓標準的list使用它。
如果這看起來對你很陌生，那就對了。沒有理由在常規代碼中使用allocator的。
定義一個Allocator
關于allocator的這一點你已經看到了：它們是模板。Allocator，和容器一樣，有value_type，而且allocator的value_type必須要匹配于使用它的容器的value_type。這有時會比較丑陋：map的value_type相當復雜，所以顯式調用allocator的map看起來象這樣的，std::map<K，V, fast_allocator<std::pair<const K, V> > >。(像往常一樣，typedef會對此有幫助。)
以一個簡單的例子開始。根據C++標準，std::allocator構建在::operator new()上。如果你正在使用一個自動化內存使用跟蹤工具，讓std::allocator更簡單些會更方便。我們可以用malloc()代替::operator new()，而且我們也不考慮（在好的std::allocator實作中可以找到的）復雜的性能優化措施。我們將這個簡單的allocator叫作malloc_allocator 。
既然malloc_allocator的內存管理很簡單，我們就能將重點集中在所有STL的allocator所共有的樣板上。首先，一些類型：allocator是一個類模板，它的實例專為某個類型T分配內存。我們提供了一序列的typedef，以描述該如何使用此類型的對象：value_type指T本身，其它的則是有各種修飾字的指針和引用。 template <class T> class malloc_allocator
{
public:
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
...
};
這些類型與STL容器中的很相似，這不是巧合：容器類常常直接從它的allocator提取這些類型。 為 什么有這么多的typedef？你可能認為pointer是多余的：它就是value_type *。絕大部份時候這是對的，但你可能有時候想定義非傳統的allocator，它的pointer是一個pointer-like的class，或非標的 廠商特定類型value_type __far *；allocator是為非標擴展提供的標準hook。不尋常的pointer類型也是存在address()成員函數的理由，它在 malloc_allocator中只是operator &()的另外一種寫法： 現在我們能開始真正的工 作：allocate()和deallocate()。它們很簡單，但并不十分象malloc()和free()。我們傳給allocate()兩個參 數：我們正在為其分派空間的對象的數目(max_size返回可能成功的最大請求值)，以及可選的一個地址值（可以被用作一個位置提示）。象 malloc_allocator這樣的簡單的allocator沒有利用那個提示，但為高性能而設計的allocator可能會利用它。返回值是一個指 向內存塊的指針，它足以容納n個value_type類型的對象并有正確的對齊。 我 們也傳給deallocate()兩個參數：當然一個是指針，但同樣還有一個元素計數值。容器必須自己掌握大小信息；傳給allocate和 deallocate的大小參數必須匹配。同樣，這個額外的參數是為效率而存在的，而同樣，malloc_allocator不使用它。 template <class T> class malloc_allocator { public: pointer allocate(size_type n, const_pointer = 0) { void* p = std::malloc(n * sizeof(T)); if (!p) throw std::bad_alloc(); return static_cast<pointer>(p); } void deallocate(pointer p, size_type) { std::free(p); } size_type max_size() const { return static_cast<size_type>(-1) / sizeof(value_type); } ... }; allocate()和 deallocate()成員函數處理的是未初始化的內存，它們不構造和銷毀對象。語句a.allocate(1)更象 malloc(sizeof(int))而不是new int。在使用從allocate()獲得的內存前，你必須在這塊內存上創建對象；在通過deallocate()歸還內存前，你需要銷毀那些對象。 C++ 語言提供一個機制以在特定的內存位置創建對象：placement new。如果你寫下new(p) T(a, b)，那么你正在調用T的構造函數產生一個新的對象，一如你寫的new T(a, b)或 T t(a, b)。區別是當你寫new(p) T(a, b)，你指定了對象被創建的位置：p所指向的地址。(自然，p必須指向一塊足夠大的內存，而且必須是未被使用的內存；你不能在相同的地址構建兩個不同的對 象。)。你也可以調用對象的析構函數，而不釋放內存，只要寫p->~T()。 這 些特性很少被使用，因為通常內存的分配和初始化是一起進行的：使用未初始化的內存是不方便的和危險的。你需要如此低層的技巧的很少幾處之一就是你在寫一個 容器類，于是allocator將內存的分配與初始化解耦。成員函數construct()調用placement new，而且成員函數destory()調用析構函數。 template <class T> class malloc_allocator
{
public:
void construct(pointer p, const value_type& x) {
new(p) value_type(x);
}
void destroy(pointer p) { p->~value_type(); }
...
};
(為什么allocator有那些成員 函數，什么時候容器可以直接使用placement new？一個理由是要隱藏笨拙的語法，而另一個是如果寫一個更復雜的allocator時你可能想在構造和銷毀對象時construct()和 destroy()還有其它一些副作用。比如，allocator可能維護一個所有當前活動對象的日志。) 這 些成員函數沒有一個是static的，因此，容器在使用allocator前做的第一件事就是創建一個allocator對象－－也就是說我們應該定義一 些構造函數。但是，我們不需要賦值運算：一旦容器創建了它的allocator，這個allocator就從沒想過會被改變。表32中的對 allocator的需求沒有包括賦值。只是基于安全，為了確保沒人偶然使用了賦值運算，我們將禁止掉這個可能自動生成的函數。 template <class T> class malloc_allocator
{
public:
malloc_allocator() {}
malloc_allocator(const malloc_allocator&) {}
~malloc_allocator() {}
private:
void operator=(const malloc_allocator&);
...
};
這些構造函數實際上沒有做任何事，因為這個allocator不需要初始化任何成員變量。基于同樣的理由，任意兩個malloc_allocator都是 可互換的；如果a1和a2的類型都是malloc_allocator<int>，我們可以自由地通過a1來allocate()內存然后通 過a2來deallocate()它。我們因此定義一個比較操作以表明所有的malloc_allocator對象是等價的： template <class T>
inline bool operator==(const malloc_allocator<T>&,
const malloc_allocator<T>&) {
return true;
}
template <class T>
inline bool operator!=(const malloc_allocator<T>&,
const malloc_allocator<T>&) {
return false;
}
你會期望一個allocator，它的不 同對象是不可替換的嗎？當然－－但很難提供一個簡單而有用的例子。一種明顯的可能性是內存池。它對大型的C程序很常見，從幾個不同的位置（“池”）分配內 存，而不是什么東西都直接使用malloc()。這樣做有幾個好處，其一是it only takes a single function call to reclaim all of the memory associated with a particular phase of the program。 使用內存池的程序可能定義諸如mempool_Alloc和mempool_Free這樣的工具函數，mempol_Alloc(n, p)從池p中分配n個字節。很容易寫出一個mmepool_alocator以匹配這樣的架構：每個mempool_allocator對象有一個成員變 量以指明它綁定在哪個池上，而mempool_allocator::allocate()將調用mempool_Alloc()從相應的池中獲取內存。 [注1] 最 后，我們到了allocator的定義體中一個微妙的部份：在不同的類型之間映射。問題是，一個allocator類，比如 malloc_allocator<int>，全部是圍繞著單個value_type構建 的：malloc_allocator<int>::pointer是int*，malloc_allocator<int> ().allocate(1)返回足夠容納一個int對象的內存，等等。然而，通常，容器類使用malloc_allocator可能必須處理超過一個類 型。比如，一個list類，不分配int對象；實際上，它分配list node對象。(我們將在下一段落研究細節。)于是，當你創建一個std::list<int, malloc_allocator<int> >時，list必須將malloc_allocator<int>轉變成為處理list_node類型的 malloc_allocator。 這 個機制稱為重綁定，它有二個部份。首先，對于給定的一個value_type是X1的allocator類型A1，你必須能夠寫出一個allocator 類型A2，它與A1完全相同，除了value_type是X2。其次，對于給定的A1類型的對象a1，你必須能夠創建一個等價的A2類型對象a2。這兩部 分都使用了成員模板，這也就是allocator不能被老的編譯器支持，或支持得很差的原因。
一般類的定義和實現組織方式：將定義放在.h文件中，實現放在.cpp文件中。 C++中的模板是C++在發展過程中新添的新生力量，template的聲明和實現不同于一般的類定義與實現和函數的聲明與定義，故在含有模板的C++程序的組織方式就不同于一般的定義與實現相分離的方式。 我曾經遇到的問題： 當在GUN中編譯時老是無法通過，錯誤信息大概是無法找到函數。然后將程序搬到VC6下編譯，同樣出現連接錯誤。 問題原因： C++標準中說明：在使用模板時C++支持兩種程序組織方式：包含模式與分離模式。包含模式也就是將類的定義與實現同放在.h 文件中，分離模式也就是將定義與實現分離，也就是我采用的方式。但很多編譯器不支持分離模式，只支持包含模式。 通常采用的解決方法： 1. 干脆直接使用包含模式，即將模板類的定義與實現同寫在.h文件中。（我不太喜歡這種寫法） 2. 使用分離模式，但是在使用時不引用模板類的頭文件，而是引用模板類的實現文件。（不太符合一般習慣） 3. 使用分離模式，在模板類頭文件中引用實現文件。（這個方法我在VC6和Dev C++下都沒有成功，不知道是哪里出了問題） 4. 使用分離模式，在模板類中頭文件中實例化一個你需要對象。（十分笨拙的方法，不利于使用） 5. 使用分離模式，但是另外定義.h文件，在這個文件中引用模板的頭文件和實現文件，在使用時引用這個另外定義的.h文件。（覺得這個方法還不錯，不過也不知道有什么缺點）
C++引用優于指針
（轉載請注明來源于金慶的專欄）
在KOK3服務器的崩潰錯誤中, 十有八九是由空指針引起的.
在C語言中, 空指針確實是錯誤的一大來源, 到處是空指針判斷, 可還是會有漏網的.
在C++中, 空指針錯誤可以大大減少, 方法就是盡量使用C++的引用代替指針.
void foo(A* pA)
{
BOOST_ASSERT(pA);
// act on pA...
}
應該改為
void foo(A& rA)
{
// act on rA...
}
如果輸入參數為const, 那更是無疑的應該使用引用作為參數.
除了參數可以轉成引用, 臨時變量也盡量使用引用. 例如:
A* pA = getA();
if (pA)
{
// act on pA...
}
可以改為
A* pA = getA();
if (pA)
{
A& rA = *pA;
// act on rA...
}
如果getA()不會返回NULL, 就將getA()改為返回引用, 而不是指針.
C++的指針知識可為及其重要的基礎，如果不懂得指針的用法，那看C++的源碼程序就太難了。C++的指針知識是個難點，必須克服的難點。 指針聲明： 1.每個數據類型都有指針類型 int* i char* c 2.指針本來也是一種類型,指針可以對應著指針類型即二級指針變量 int** i 即 （int*）* i【int指針類型的指針i】 3.一個*只能修飾一個指針 int* i,p 【i為指針，p為int變量】 要想一下聲明多個指針，則可以：int* i,*p 指針賦值： 1.指針也可以初始化，賦值或初始化的值是同類型實體（即實體變量）的地址 int i=10; int* ip=&i (&表示實體的地址) int* ipt=&10 是不可以的，10是實體，而不認可具有空間地址（所以說是實體變量地址才有效） 2.指針直接賦實體值 int i=10; int* ip=&i; int* ipt=10 不可以，指針初始化必須是實體地址 *ip=20 可以，指針間訪操作 這里的*ip為什么能直接給實體值呢？ 因為*ip是所指向實體地址的間訪操作，也就是指針指向實體的時候是可以讀寫操作的。其實這里還是賦值的地址。 3.空指針不能賦實體值 int* ip; *ip=10 不可以 這里的*ip為什么又不能給實體值了呢？ 因為這里的指針*ip沒有經過初始化，*ip沒有指向實體，為空指針，則就不能讀寫了。 指針間的操作 當指針指向具體實體后，指針也就有了具體的實體值和具體的空間地址，這時候就可以被二級指針所操作 int i=10; int* ip=&10; int** iip=&ip; 理解了上面的指針賦值，那么其余的指針間操作就好操作了，必須理解清楚指針在各種情況下的表示。 給指針賦值，必須是個地址，各種形式的賦值只是表現出的形式不一樣，實際指針只能指向實體的地址。指針在賦值時必須是與指針類型相同的類型實體地址。但實 際的存儲空間的實體都是以二進制數進行存儲的，那么當一個float的實體地址被一個int指針指向時，這個float實體就會被強制轉換為int實體， 那么數據就出現變動。這是危險的。我理解的是，指針不能在類型不同時進行轉換。 今天就到此了，明天還要繼續。天，有點想發狂的沖動，還有指針運算、限定、引用，函數指針。頭都要大了...
在C/C++中，對字符串的操作有很多值得注意的問題，同樣，C/C++對時間的操作也有許多值得大家注意的地方。下面，在這篇文章中，筆者將主要介紹在C/C++中時間和日期的使用方法.
1．概念
通過學習許多C/C++庫，你可以有很多操作、使用時間的方法。但在這之前你需要了解一些“時間”和“日期”的概念，主要有以下幾個：
Coordinated Universal Time（UTC）：協調世界時，又稱為世界標準時間，也就是大家所熟知的格林威治標準時間（Greenwich Mean Time，GMT）。比如，中國內地的時間與UTC的時差為+8，也就是UTC+8。美國是UTC-5。
Calendar Time：日歷時間，是用“從一個標準時間點到此時的時間經過的秒數”來表示的時間。這個標準時間點對不同的編譯器來說會有所不同，但對一個編譯系統來說，這個標準時間點是不變的，該編譯系統中的時間對應的日歷時間都通過該標準時間點來衡量，所以可以說日歷時間是“相對時間”，但是無論你在哪一個時區，在同一時刻對同一個標準時間點來說，日歷時間都是一樣的。
epoch：時間點。時間點在標準C/C++中是一個整數，它用此時的時間和標準時間點相差的秒數（即日歷時間）來表示。
clock tick：時鐘計時單元（而不把它叫做時鐘滴答次數），一個時鐘計時單元的時間長短是由CPU控制的。一個clock tick不是CPU的一個時鐘周期，而是C/C++的一個基本計時單位。
我們可以使用ANSI標準庫中的time.h頭文件。這個頭文件中定義的時間和日期所使用的方法，無論是在結構定義，還是命名，都具有明顯的C語言風格。下面，我將說明在C/C++中怎樣使用日期的時間功能。
2． 計時
C/C++中的計時函數是clock()，而與其相關的數據類型是clock_t。在MSDN中，查得對clock函數定義如下：
clock_t clock( void );
這個函數返回從“開啟這個程序進程”到“程序中調用clock()函數”時之間的CPU時鐘計時單元（clock tick）數，在MSDN中稱之為掛鐘時間（wal-clock）。其中clock_t是用來保存時間的數據類型，在time.h文件中，我們可以找到對它的定義：
#ifndef _CLOCK_T_DEFINED
typedef long clock_t;
#define _CLOCK_T_DEFINED
#endif
很明顯，clock_t是一個長整形數。在time.h文件中，還定義了一個常量CLOCKS_PER_SEC，它用來表示一秒鐘會有多少個時鐘計時單元，其定義如下：
#define CLOCKS_PER_SEC ((clock_t)1000)
可以看到每過千分之一秒（1毫秒），調用clock（）函數返回的值就加1。下面舉個例子，你可以使用公式clock()/CLOCKS_PER_SEC來計算一個進程自身的運行時間：
void elapsed_time()
{
printf("Elapsed time:%u secs.\n",clock()/CLOCKS_PER_SEC);
}
當然，你也可以用clock函數來計算你的機器運行一個循環或者處理其它事件到底花了多少時間：
#include “stdio.h”
#include “stdlib.h”
#include “time.h”
int main( void )
{
long i = 10000000L;
clock_t start, finish;
double duration;
/* 測量一個事件持續的時間*/
printf( "Time to do %ld empty loops is ", i );
start = clock();
while( i-- ) ;
finish = clock();
duration = (double)(finish - start) / CLOCKS_PER_SEC;
printf( "%f seconds\n", duration );
system("pause");
}
在筆者的機器上，運行結果如下：
Time to do 10000000 empty loops is 0.03000 seconds
上面我們看到時鐘計時單元的長度為1毫秒，那么計時的精度也為1毫秒，那么我們可不可以通過改變CLOCKS_PER_SEC的定義，通過把它定義的大一些，從而使計時精度更高呢？通過嘗試，你會發現這樣是不行的。在標準C/C++中，最小的計時單位是一毫秒。
3．與日期和時間相關的數據結構
在標準C/C++中，我們可通過tm結構來獲得日期和時間，tm結構在time.h中的定義如下：
#ifndef _TM_DEFINED
struct tm {
int tm_sec; /* 秒 – 取值區間為[0,59] */
int tm_min; /* 分 - 取值區間為[0,59] */
int tm_hour; /* 時 - 取值區間為[0,23] */
int tm_mday; /* 一個月中的日期 - 取值區間為[1,31] */
int tm_mon; /* 月份（從一月開始，0代表一月） - 取值區間為[0,11] */
int tm_year; /* 年份，其值等于實際年份減去1900 */
int tm_wday; /* 星期 – 取值區間為[0,6]，其中0代表星期天，1代表星期一，以此類推 */
int tm_yday; /* 從每年的1月1日開始的天數 – 取值區間為[0,365]，其中0代表1月1日，1代表1月2日，以此類推 */
int tm_isdst; /* 夏令時標識符，實行夏令時的時候，tm_isdst為正。不實行夏令時的進候，tm_isdst為0；不了解情況時，tm_isdst()為負。*/
};
#define _TM_DEFINED
#endif
ANSI C標準稱使用tm結構的這種時間表示為分解時間(broken-down time)。
而日歷時間（Calendar Time）是通過time_t數據類型來表示的，用time_t表示的時間（日歷時間）是從一個時間點（例如：1970年1月1日0時0分0秒）到此時的秒數。在time.h中，我們也可以看到time_t是一個長整型數：
#ifndef _TIME_T_DEFINED
typedef long time_t; /* 時間值 */
#define _TIME_T_DEFINED /* 避免重復定義 time_t */
#endif
大家可能會產生疑問：既然time_t實際上是長整型，到未來的某一天，從一個時間點（一般是1970年1月1日0時0分0秒）到那時的秒數（即日歷時間）超出了長整形所能表示的數的范圍怎么辦？對time_t數據類型的值來說，它所表示的時間不能晚于2038年1月18日19時14分07秒。為了能夠表示更久遠的時間，一些編譯器廠商引入了64位甚至更長的整形數來保存日歷時間。比如微軟在Visual C++中采用了__time64_t數據類型來保存日歷時間，并通過_time64()函數來獲得日歷時間（而不是通過使用32位字的time()函數），這樣就可以通過該數據類型保存3001年1月1日0時0分0秒（不包括該時間點）之前的時間。
在time.h頭文件中，我們還可以看到一些函數，它們都是以time_t為參數類型或返回值類型的函數：
double difftime(time_t time1, time_t time0);
time_t mktime(struct tm * timeptr);
time_t time(time_t * timer);
char * asctime(const struct tm * timeptr);
char * ctime(const time_t *timer);
此外，time.h還提供了兩種不同的函數將日歷時間（一個用time_t表示的整數）轉換為我們平時看到的把年月日時分秒分開顯示的時間格式tm：
struct tm * gmtime(const time_t *timer);
struct tm * localtime(const time_t * timer);
通過查閱MSDN，我們可以知道Microsoft C/C++ 7.0中時間點的值（time_t對象的值）是從1899年12月31日0時0分0秒到該時間點所經過的秒數，而其它各種版本的Microsoft C/C++和所有不同版本的Visual C++都是計算的從1970年1月1日0時0分0秒到該時間點所經過的秒數。
4．與日期和時間相關的函數及應用
在本節，我將向大家展示怎樣利用time.h中聲明的函數對時間進行操作。這些操作包括取當前時間、計算時間間隔、以不同的形式顯示時間等內容。
4.1 獲得日歷時間
我們可以通過time()函數來獲得日歷時間（Calendar Time），其原型為：
time_t time(time_t * timer);
如果你已經聲明了參數timer，你可以從參數timer返回現在的日歷時間，同時也可以通過返回值返回現在的日歷時間，即從一個時間點（例如：1970年1月1日0時0分0秒）到現在此時的秒數。如果參數為空（NUL），函數將只通過返回值返回現在的日歷時間，比如下面這個例子用來顯示當前的日歷時間：
#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *ptr;
time_t lt;
lt =time(NUL);
printf("The Calendar Time now is %d\n",lt);
return 0;
}
運行的結果與當時的時間有關，我當時運行的結果是：
The Calendar Time now is 1122707619
其中1122707619就是我運行程序時的日歷時間。即從1970年1月1日0時0分0秒到此時的秒數。
4.2 獲得日期和時間
這里說的日期和時間就是我們平時所說的年、月、日、時、分、秒等信息。從第2節我們已經知道這些信息都保存在一個名為tm的結構體中，那么如何將一個日歷時間保存為一個tm結構的對象呢？
其中可以使用的函數是gmtime()和localtime()，這兩個函數的原型為：
struct tm * gmtime(const time_t *timer);
struct tm * localtime(const time_t * timer);
其中gmtime()函數是將日歷時間轉化為世界標準時間（即格林尼治時間），并返回一個tm結構體來保存這個時間，而localtime()函數是將日歷時間轉化為本地時間。比如現在用gmtime()函數獲得的世界標準時間是2005年7月30日7點18分20秒，那么我用localtime()函數在中國地區獲得的本地時間會比世界標準時間晚8個小時，即2005年7月30日15點18分20秒。下面是個例子：
#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *local;
time_t t;
t=time(NUL);
local=localtime(&t);
printf("Local hour is: %d\n",local->tm_hour);
local=gmtime(&t);
printf("UTC hour is: %d\n",local->tm_hour);
return 0;
}
運行結果是：
Local hour is: 15
UTC hour is: 7
4.3 固定的時間格式
我們可以通過asctime()函數和ctime()函數將時間以固定的格式顯示出來，兩者的返回值都是char*型的字符串。返回的時間格式為：
星期幾 月份 日期 時:分:秒 年\n\0
例如：Wed Jan 02 02:03:55 1980\n\0
其中\n是一個換行符，\0是一個空字符，表示字符串結束。下面是兩個函數的原型：
char * asctime(const struct tm * timeptr);
char * ctime(const time_t *timer);
其中asctime()函數是通過tm結構來生成具有固定格式的保存時間信息的字符串，而ctime()是通過日歷時間來生成時間字符串。這樣的話，asctime（）函數只是把tm結構對象中的各個域填到時間字符串的相應位置就行了，而ctime（）函數需要先參照本地的時間設置，把日歷時間轉化為本地時間，然后再生成格式化后的字符串。在下面，如果t是一個非空的time_t變量的話，那么：
printf(ctime(&t));
等價于：
struct tm *ptr;
ptr=localtime(&t);
printf(asctime(ptr));
那么，下面這個程序的兩條printf語句輸出的結果就是不同的了（除非你將本地時區設為世界標準時間所在的時區）：
#include "time.h"
#include "stdio.h"
int main(void)
{
struct tm *ptr;
time_t lt;
lt =time(NUL);
ptr=gmtime(<);
printf(asctime(ptr));
printf(ctime(<));
return 0;
}
運行結果：
Sat Jul 30 08:43:03 2005
Sat Jul 30 16:43:03 2005
4.4 自定義時間格式
我們可以使用strftime（）函數將時間格式化為我們想要的格式。它的原型如下：
size_t strftime(
char *strDest,
size_t maxsize,
const char *format,
const struct tm *timeptr
);
我們可以根據format指向字符串中格式命令把timeptr中保存的時間信息放在strDest指向的字符串中，最多向strDest中存放maxsize個字符。該函數返回向strDest指向的字符串中放置的字符數。
函數strftime()的操作有些類似于sprintf()：識別以百分號(%)開始的格式命令集合，格式化輸出結果放在一個字符串中。格式化命令說明串strDest中各種日期和時間信息的確切表示方法。格式串中的其他字符原樣放進串中。格式命令列在下面，它們是區分大小寫的。
%a 星期幾的簡寫
%A 星期幾的全稱
%b 月分的簡寫
%B 月份的全稱
%c 標準的日期的時間串
%C 年份的后兩位數字
%d 十進制表示的每月的第幾天
%D 月/天/年
%e 在兩字符域中，十進制表示的每月的第幾天
%F 年-月-日
%g 年份的后兩位數字，使用基于周的年
%G 年分，使用基于周的年
%h 簡寫的月份名
%H 24小時制的小時
%I 12小時制的小時
%j 十進制表示的每年的第幾天
%m 十進制表示的月份
%M 十時制表示的分鐘數
%n 新行符
%p 本地的AM或PM的等價顯示
%r 12小時的時間
%R 顯示小時和分鐘：hh:mm
%S 十進制的秒數
%t 水平制表符
%T 顯示時分秒：hh:mm:ss
%u 每周的第幾天，星期一為第一天 （值從0到6，星期一為0）
%U 第年的第幾周，把星期日做為第一天（值從0到53）
%V 每年的第幾周，使用基于周的年
%w 十進制表示的星期幾（值從0到6，星期天為0）
%W 每年的第幾周，把星期一做為第一天（值從0到53）
%x 標準的日期串
%X 標準的時間串
%y 不帶世紀的十進制年份（值從0到99）
%Y 帶世紀部分的十進制年份
%z，%Z 時區名稱，如果不能得到時區名稱則返回空字符。
%% 百分號
如果想顯示現在是幾點了，并以12小時制顯示，就象下面這段程序：
#include “time.h”
#include “stdio.h”
int main(void)
{
struct tm *ptr;
time_t lt;
char str[80];
lt=time(NUL);
ptr=localtime(<);
strftime(str,100,"It is now %I %p",ptr);
printf(str);
return 0;
}
其運行結果為：
It is now 4PM
而下面的程序則顯示當前的完整日期：
#include <stdio.h>
#include <time.h>
void main( void )
{
struct tm *newtime;
char tmpbuf[128];
time_t lt1;
time( <1 );
newtime=localtime(<1);
strftime( tmpbuf, 128, "Today is %A, day %d of %B in the year %Y.\n", newtime);
printf(tmpbuf);
}
運行結果：
Today is Saturday, day 30 of July in the year 2005.
4.5 計算持續時間的長度
有時候在實際應用中要計算一個事件持續的時間長度，比如計算打字速度。在第1節計時部分中，我已經用clock函數舉了一個例子。Clock()函數可以精確到毫秒級。同時，我們也可以使用difftime()函數，但它只能精確到秒。該函數的定義如下：
double difftime(time_t time1, time_t time0);
雖然該函數返回的以秒計算的時間間隔是double類型的，但這并不說明該時間具有同double一樣的精確度，這是由它的參數覺得的（time_t是以秒為單位計算的）。比如下面一段程序：
#include "time.h"
#include "stdio.h"
#include "stdlib.h"
int main(void)
{
time_t start,end;
start = time(NUL);
system("pause");
end = time(NUL);
printf("The pause used %f seconds.\n",difftime(end,start));//<-
system("pause");
return 0;
}
運行結果為：
請按任意鍵繼續. . .
The pause used 2.000000 seconds.
請按任意鍵繼續. . .
可以想像，暫停的時間并不那么巧是整整2秒鐘。其實，你將上面程序的帶有“//<-”注釋的一行用下面的一行代碼替換：
printf("The pause used %f seconds.\n",end-start);
其運行結果是一樣的。
4.6 分解時間轉化為日歷時間
這里說的分解時間就是以年、月、日、時、分、秒等分量保存的時間結構，在C/C++中是tm結構。我們可以使用mktime（）函數將用tm結構表示的時間轉化為日歷時間。其函數原型如下：
time_t mktime(struct tm * timeptr);
其返回值就是轉化后的日歷時間。這樣我們就可以先制定一個分解時間，然后對這個時間進行操作了，下面的例子可以計算出1997年7月1日是星期幾：
#include "time.h"
#include "stdio.h"
#include "stdlib.h"
int main(void)
{
struct tm t;
time_t t_of_day;
t.tm_year=1997-1900;
t.tm_mon=6;
t.tm_mday=1;
t.tm_hour=0;
t.tm_min=0;
t.tm_sec=1;
t.tm_isdst=0;
t_of_day=mktime(&t);
printf(ctime(&t_of_day));
return 0;
}
運行結果：
Tue Jul 01 00:00:01 1997
現在注意了，有了mktime()函數，是不是我們可以操作現在之前的任何時間呢？你可以通過這種辦法算出1945年8月15號是星期幾嗎？答案是否定的。因為這個時間在1970年1月1日之前，所以在大多數編譯器中，這樣的程序雖然可以編譯通過，但運行時會異常終止。
從今天決定重溫C,C++,準備從<<21天學通C語言>>入手,雖不是每天一課程,但每次也要完成一天的課程.并在這里寫出感想.來更進一步! NO1 C是什么? C的特點? 靈活,可移植,模塊化,關鍵字少 C,C++區別 C++是C語言的超集,包括了C++的所有內容,同時增加了面對對象編程方面的內容. 創建C的步驟? 確定程序的目標----用什么樣的方法實現它----實現程序----運行程序 程序開發周期
1. c++中string到int的轉換 1) 在C標準庫里面，使用atoi： #include <cstdlib>
#include <string> std::string text = "152";
int number = std::atoi( text.c_str() );
if (errno == ERANGE) //可能是std::errno
{
//number可能由于過大或過小而不能完全存儲
}
else if (errno == ????)
//可能是EINVAL
{
//不能轉換成一個數字
} 2) 在C++標準庫里面，使用stringstream：(stringstream 可以用于各種數據類型之間的轉換) #include <sstream>
#include <string> std::string text = "152";
int number;
std::stringstream ss;
ss << text;//可以是其他數據類型
ss >> number; //string -> int
if (! ss.good())
{
//錯誤發生
}
ss << number;// int->string
string str = ss.str();
if (! ss.good())
{
//錯誤發生
} 3) 在Boost庫里面，使用lexical_cast： #include <boost/lexical_cast.hpp>
#include <string> try
{
std::string text = "152";
int number = boost::lexical_cast< int >( text );
}
catch( const boost::bad_lexical_cast & )
{
//轉換失敗
} 2.string 轉 CString
CString.format(”%s”, string.c_str());
用c_str()確實比data()要好； 3.char 轉 CString
CString.format(”%s”, char*); 4.char 轉 string
string s(char *);
只能初始化，在不是初始化的地方最好還是用assign(). 5.string 轉 char *
char *p = string.c_str(); 6.CString 轉 string
string s(CString.GetBuffer());
GetBuffer()后一定要ReleaseBuffer(),否則就沒有釋放緩沖區所占的空間.
7.字符串的內容轉換為字符數組和C—string
(1) data(),返回沒有”\0“的字符串數組
(2) c_str()，返回有”\0“的字符串數組
(3) copy() 8.CString與int、char*、char[100]之間的轉換 (1) CString互轉int 將字符轉換為整數，可以使用atoi、_atoi64或atol。而將數字轉換為CString變量，可以使用CString的Format函數。如
CString s;
int i = 64;
s.Format(”%d”, i)
Format函數的功能很強，值得你研究一下。 void CStrDlg::OnButton1()
{
CString
ss=”1212.12″;
int temp=atoi(ss);
CString aa;
aa.Format(”%d”,temp);
AfxMessageBox(”var is ” + aa);
} (2) CString互轉char* ///char * TO cstring
CString strtest;
char * charpoint;
charpoint=”give string a value”; //?
strtest=charpoint; ///cstring TO char *
charpoint=strtest.GetBuffer(strtest.GetLength()); (3) 標準C里沒有string,char *==char []==string, 可以用CString.Format(”%s”,char *)這個方法來將char *轉成CString。
要把CString轉成char *，用操作符（LPCSTR）CString就可以了。
CString轉換 char[100]
char a[100];
CString str(”aaaaaa”);
strncpy(a,(LPCTSTR)str,sizeof(a));
C++廣泛應用在不同領域，使用者以數百萬計。根據近十年的調查，C++的流行程度約穩定排行第3位(于C/Java之后)。 C++經歷長期的實踐和演化，才成為今日的樣貌。1998年，C++標準委員會排除萬難，使C++成為ISO標準(俗稱C++98)，當中含非常強大的標準模版庫(standard template library, STL)。之后委員會在2005年提交了有關標準庫的第一個技術報告(簡稱TR1)，并為下一個標準C++0x而努力。可惜C++0x并不能在200x年完成，各界希望新標準能于2011年內出臺。 流行的C++編譯器中，微軟Visual C++ 2010已實現部分C++0x語法并加入TR1擴充庫，而gcc對C++0x語法和庫的支持比VC2010更多。 應否選擇C++ 哪些程序適宜使用C++? C++并非萬能丹，我按經驗舉出一些C++的適用時機。 - C++適合構造程序中需求較穩定的部分，需求變化較大的部分可使用腳本語言；
- 程序須盡量發揮硬件的最高性能，且性能瓶頸在于CPU和內存；
- 程序須頻繁地與操作系統或硬件溝通；
- 程序必須使用C++框架/庫，如大部分游戲引擎(如Unreal/Source)及中間件(如Havok/FMOD)，雖然有些C++庫提供其他語言的綁定，但通常原生的API性能最好、最新；
- 項目中某個目標平臺只提供C++編譯器的支持。
按應用領域來說，C++適用于開發服務器軟件、桌面應用、游戲、實時系統、高性能計算、嵌入式系統等。 使用C++還是C? C++和C的設計哲學并不一樣，兩者取舍不同，所以不同的程序員和軟件項目會有不同選擇，難以一概而論。與C++相比，C具備編譯速度快、容易學 習、顯式描述程序細節、較少更新標準(后兩者也可同時視為缺點)等優點。在語言層面上，C++包含絕大部分C語言的功能(例外之一，C++沒有C99的變長數組VLA)，且提供OOP和GP的特性。但其實用C也可實現OOP思想，亦可利用宏去實現某程度的GP，只不過C++的語法能較簡潔、自動地實現OOP/GP。C++的RAII(resource acquisition is initialization，資源獲取就是初始化)特性比較獨特，C/C#/Java沒有相應功能。回顧歷史，Stroustrup開發的早期C++編譯器Cpre/Cfront是把C++源代碼翻譯為C，再用C編譯器編譯的。由此可知，C++編寫的程序，都能用等效的C程序代替，但C++在語言層面上提供了OOP/GP語法、更嚴格的類型檢查系統、大量額外的語言特性(如異常、RTTI等)， 并且C++標準庫也較豐富。有時候C++的語法可使程序更簡潔，如運算符重載、隱式轉換。但另一方面，C語言的API通常比C++簡潔，能較容易供其他語 言程序調用。因此，一些C++庫會提供C的API封裝，同時也可供C程序調用。相反，有時候也會把C的API封裝成C++形式，以支持RAII和其他 C++庫整合等。 為何C++性能可優于其他語言? 相對運行于虛擬機語言(如C#/Java)，C/C++直接以靜態形式把源程序編譯為目標平臺的機器碼。一般而言，C/C++程序在編譯及鏈接時可 進行的優化最豐富，啟動時的速度最快，運行時的額外內存開銷最少。而C/C++相對動態語言(如Python/Lua)也減少了運行時的動態類型檢測。此 外，C/C++的運行行為是確定的，且不會有額外行為(例如C#/Java必然會初始化變量)，也不會有如垃圾收集(GC)而造成的不確定性延遲，而且C /C++的數據結構在內存中的布局也是確定的。有時C++的一些功能會使程序性能優于C，當中以內聯和模版最為突出，這兩項功能使C++標準庫的 sort()通常比C標準庫的qsort()快多倍(C可用宏或人手編碼去解決此問題)。另一方面，C/C++能直接映射機器碼，之間沒有另一層中間語言，因此可以做底層優化，例如使用內部(intrinsic)函數和嵌入匯編語言。然而，許多C++的性能優點并非免費午餐，代價包括較長的編譯鏈接時間和較易出錯，因而增加開發時間和成本，這點稍后補充。 我進行了一個簡單全局渲染性能測試(512x512像素，每像素10000個采樣)，C++ 1小時36分、Java 3小時18分、Python約18天、Ruby約351天。評測方式和其他語言的結果詳見博文。 C++常見問題 C++源代碼跨平臺嗎? C++有不錯的跨平臺能力，但由于直接映射硬件，因性能優化的關系，跨平臺能力不及Java及多數腳本語言。然而，實踐跨平臺的C++軟件還是可行的，但須注意以下問題： - C++標準沒有規定原始數據類型(如int)的大小，需要特定大小的類型時，可自訂類型(如int32_t)，同時對任何類型使用sizeof()而不假設其大小；
- 字節序(byte order)按CPU有所不同，特別要注意二進制輸入輸出、reinterpret_cast法；
- 原始數據和結構類型的地址對齊有差異；
- 編譯器提供的一些編譯器或平臺專用擴充指令；
- 避免作應用二進制接口(application binary interface, ABI)的假設，例如調用函數時參數的取值順序在C/C++中沒定義，在C++中也不可隨便假設RTTI/虛表等實現方式。
總括而言，跨平臺C++軟件可在頭文件中用宏檢測編譯器和平臺，再用宏、typedef、自定平臺相關實現等方法去實踐跨平臺，C++標準不會提供這類幫助。 C++程序容易崩潰? 和許多語言相比，C/C++提供不安全的功能以最優化性能，有可能造成崩潰。但要注意，很多運行時錯誤，如向空指針/引用解引用、數組越界、堆棧溢 出等，其他語言也會報錯或拋出異常，這些都是程序問題，而不是語言本身的問題。有些意見認為，出現這類運行時錯誤，應該盡量寫入日志并立即崩潰，不該讓程 序繼續運行，以免造成更大的影響(例如程序繼續把內存中錯誤的數據覆寫文件)。若要容錯，可按業務把程序分割為多進程，像Chrome或使用fork()的形式。然而，C++有許多機制可以減少錯誤，例如以string代替C字符串；以vector或array(TR1)代替原始數組(有些實現可在調試模式檢測越界)；使用智能指針也能減少一些原始指針的問題。另外，我最常遇到的Bug，就是沒有初始化成員變量，有時會導致崩潰，而且調試版和發行版的行為可能不同。 C++要手動做內存管理? C++同時提供在堆棧上的自動局部變量，以及從自由存儲(free store)分配的對象。對于后者，程序員需手動釋放，或使用不同的容器和智能指針。 C++程序員經常進一步優化內存，自定義內存分配策略以提升效能，例如使用對象池、自定義的單向/雙向堆棧區等。雖然C++0x還沒加入GC功能，但也可 以自行編寫或使用現成庫。此外，C/C++也可以直接使用操作系統提供的內存相關功能，例如內存映射文件、共享內存等。 使用C++常要重造輪子? 我曾參與的C++項目，都會重造不少標準庫已提供的功能，此情況在其他語言中較少出現。我試圖分析個中原因。首先，C++標準庫相對很多語言來說是 貧乏的，各開發者便會重復地制造自訂庫。從另一個角度看，C++標準庫是用C++編寫的(很多其他語言不用自身而是用C/C++去編寫庫)，在能力和性能 上，自訂庫和標準庫并無本質差別；另外，標準庫為通用而設，對不同平臺及多種使用需求作取舍，性能上有所影響，例如EA公司就曾發表自制的EASTL規 格，描述游戲開發方面對STL的性能及功能需求的特點；此外，多個C++庫一起使用，經常會因規范不同而引起沖突，又或功能重疊，所以項目可能須自行開 發，或引入其他庫的概念或實現(如Boost/TR1/Loki)，改寫以符合項目規范。 C++編譯速度很慢? 錯，是非常慢。我認為C++可能是實用程序語言中編譯速度最慢的。此問題涉及C++沿用C的編譯鏈接方式，又加入了復雜的類/泛型聲明和內聯機制，使編譯時間倍增。在C++對編譯方法改革之前(如module提案)，可使用以下技巧改善：第一，使用pimpl手法，因性能損耗應用于調用次數不多的類；第二，僅包含必要頭文件，并盡量使用及提供前置聲明版本的頭文件(如iosfwd)；第三采用基于接口的設計，但須注意虛函數調用成本；第四，采用unity build，即把多個cpp文件結合在一個編譯單元進行編譯；第五，采用分布式生成系統如IncrediBuild。 C++缺乏什么功能? 雖然C++已經非常復雜，但仍缺少很多常見功能。 C++0x作出了不少改善，例如語言方面加入Lambda函數、閉包、類型推導聲明等，而庫方面則加入正則表達式、采用哈希表的 unordered_set/unordered_map、引用計數智能指針shared_ptr/weak_ptr等。但最值得留意的是C++0x引入 多線程的語法和庫功能，這是C++演進的一大步。然而，模組、GC、反射機制等功能雖有提案，卻未加進C++0x。 C++使用建議 為應用挑選特性集 我同意Stroustrup關于使用C++各種技術的回應：“你可以做，不意味著你必須這么做。(Just because you can do it, doesn't mean that you have to.)” C++充滿豐富的特性，但同時帶來不同問題，例如過分復雜、編譯及運行性能的損耗。一般可考慮是否使用多重繼承、異常、RTTI，并調節使用模版及模版元 編程的程度。使用過分復雜的設計和功能，可能會令部分團隊成員更難理解和維護。 為團隊建立編程規范 C++的編碼自由度很高，容易編寫風格迥異的代碼，C++本身也沒有定義一些標準規范。而且，C++的源文件物理構成，較許多語言復雜。因此，除了決定特性集，每個團隊應建立一套編程規范，包括源文件格式(可使用文件模版)、花括號風格。 盡量使用C++風格而非C風格 由于C++有對C兼容的包袱，一些功能可以使用C風格實現，但最好使用C++提供的新功能。最基本的是盡量以具名常量、內聯函數和泛型取代宏，只把 宏用在條件式編譯及特殊情況。舊式的C要求局部變量聲明在作用域開端，C++則無此限制，應把變量聲明盡量置于鄰近其使用的地方，for()的循環變量聲 明可置于for的括號內。 C++中能加強類型安全的功能應盡量使用，例如避免“萬能”指針void *，而使用個別或泛型類型；用bool而非int表示布爾值；選用4種C++ cast關鍵字代替簡單的強制轉換。 結合其他語言 如前文所述，C++并非適合所有應用情境，有時可以混合其他語言使用，包括用C++擴展其他語言，或在C++程序中嵌入腳本語言引擎。對于后者，除了使用各種腳本語言的專門API，還可使用Boost或SWIG作整合。 C++學習建議 C++缺點之一，是相對許多語言復雜，而且難學難精。許多人說學習C語言只需一本K&R《C程序設計語言》即可，但C++書籍卻是多不勝數。我是從C進入C++，皆是靠閱讀自學。在此分享一點學習心得。個人認為，學習C++可分為4個層次： - 第一層次，C++基礎：挑選一本入門書籍，如《C++ Primer》、《C++大學教程》、或Stroustrup撰寫的經典《C++程序設計語言》或他一年半前的新作《C++程序設計原理與實踐》，而一般C++課程也止于此，另外《C++ 標準程序庫》及《The C++ Standard Library Extensions》可供參考；
- 第二層次，正確高效地使用C++：此層次開始必須自修，閱讀過《(More)Effective C++》、《(More)Exceptional C++》、《Effective STL》及《C++編程規范》等，才適宜踏入專業C++開發之路；
- 第三層次，深入了解C++：關于全局問題可讀《深入探索C++對象模型》、《Imperfect C++》、《C++沉思錄》、《STL源碼剖析》，要挑戰智商，可看關于模版及模版元編程的書籍如《C++ Templates》、《C++設計新思維》、《C++模版元編程》；
- 第四層次，研究C++：閱讀《C++語言的設計和演化》、《編程的本質》(含STL設計背后的數學根基)、C++標準文件《ISO/IEC 14882:2003》、C++標準委員會的提案書和報告書、關于C++的學術文獻。
由于我主要是應用C++，大約只停留于第二、三個層次。然而，C++只是軟件開發的一環而已，單憑語言并不能應付業務和工程上的問題。建議讀者不要 強求幾年內“徹底學會C++的知識”，到達第二層左右便從工作實戰中汲取經驗，有興趣才慢慢繼續學習更高層次的知識。雖然學習C++有難度，但也是相當有 趣且有滿足感的。
|
|
|
| | 日 | 一 | 二 | 三 | 四 | 五 | 六 |
|---|
| 27 | 28 | 29 | 30 | 1 | 2 | 3 | | 4 | 5 | 6 | 7 | 8 | 9 | 10 | | 11 | 12 | 13 | 14 | 15 | 16 | 17 | | 18 | 19 | 20 | 21 | 22 | 23 | 24 | | 25 | 26 | 27 | 28 | 29 | 30 | 31 | | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
|
導航
統計
常用鏈接
留言簿(1)
隨筆檔案
搜索
最新評論
閱讀排行榜
評論排行榜
|
|