Where there is a dream ,there is hope

盡管函數指針被廣泛用于實現函數回調，但C++還提供了一個重要的實現回調函數的方法，那就是函數對象。函數對象（也稱“算符”）是重載了“()”操作符的普通類對象。因此從語法上講，函數對象與普通的函數行為類似。

        用函數對象代替函數指針有幾個優點，首先，因為對象可以在內部修改而不用改動外部接口，因此設計更靈活，更富有彈性。函數對象也具備有存儲先前調用結果的數據成員。在使用普通函數時需要將先前調用的結果存儲在全程或者本地靜態變量中，但是全程或者本地靜態變量有某些我們不愿意看到的缺陷。
        其次，在函數對象中編譯器能實現內聯調用，從而更進一步增強了性能。這在函數指針中幾乎是不可能實現的。

下面舉例說明如何定義和使用函數對象。首先，聲明一個普通的類并重載“()”操作符：

class Negate 
{
public: 
int operator() (int n) { return -n;} 
};

        重載操作語句中，記住第一個圓括弧總是空的,因為它代表重載的操作符名；第二個圓括弧是參數列表。一般在重載操作符時，參數數量是固定的，而重載“()” 操作符時有所不同，它可以有任意多個參數。

        因為在Negate中內建的操作是一元的（只有一個操作數），重載的“()”操作符也只有一個參數。返回類型與參數類型相同-本例中為int。函數返回與參數符號相反的整數。

使用函數對象

        我們現在定義一個叫Callback()的函數來測試函數對象。Callback()有兩個參數：一個為int一個是對類Negate的引用。 Callback()將函數對象neg作為一個普通的函數名：

#include <iostream>
using std::cout;

void Callback(int n, Negate & neg) 
{
int val = neg(n); //調用重載的操作符“()” 
cout << val;
}

不要的代碼中，注意neg是對象，而不是函數。編譯器將語句

int val = neg(n);

轉化為

int val = neg.operator()(n);

        通常，函數對象不定義構造函數和析構函數。因此，在創建和銷毀過程中就不會發生任何問題。前面曾提到過，編譯器能內聯重載的操作符代碼，所以就避免了與函數調用相關的運行時問題。

為了完成上面個例子，我們用主函數main()實現Callback()的參數傳遞：

int main() 
{
Callback(5, Negate() ); //輸出 -5
}

本例傳遞整數5和一個臨時Negate對象到Callback()，然后程序輸出-5。

模板函數對象

        從上面的例子中可以看出，其數據類型被限制在int，而通用性是函數對象的優勢之一，如何創建具有通用性的函數對象呢？方法是使用模板，也就是將重載的操作符“（）”定義為類成員模板，以便函數對象適用于任何數據類型：如double，_int64或char：

class GenericNegate
{
public: 
template <class T> T operator() (T t) const {return -t;}
};

int main()
{
GenericNegate negate;
cout<< negate(5.3333); // double
cout<< negate(10000000000i64); // __int64
}

如果用普通的回調函數實現上述的靈活性是相當困難的。

標準庫中函數對象

        C++標準庫定義了幾個有用的函數對象，它們可以被放到STL算法中。例如，sort()算法以
判斷對象（predicate object）作為其第三個參數。判斷對象是一個返回Boolean型結果的
模板化的函數對象。可以向sort()傳遞greater<>或者less<>來強行實現排序的升序或降序：

#include <functional> // for greater<> and less<>
#include <algorithm> //for sort() 
#include <vector>
using namespace std;

int main()
{ 
vector <int> vi;
//..填充向量
sort(vi.begin(), vi.end(), greater<int>() );//降序( descending )
sort(vi.begin(), vi.end(), less<int>() ); //升序 ( ascending )
}

用C++的stl庫，相信大家都有用vector的經歷，畢竟vector支持直接下標方式取數據的確方便很多。

但是vector默認是不提供find方法的，所以我們在查找的時候，通常這樣寫代碼：

vector<int> vec;
for(unsigned int i = 0;i<vec.size();++i)
{
    if(vec[i]==xxx)
    {
        break;
    }
}

并不是說提供不了，而是stl庫中實際上已經有通用的find函數（不止find……）

可以看一下下面的代碼：

int main(int argc,char* argv[])
{
    vector<int> vec;
    vec.push_back(123);
    vec.push_back(456);
    vector<int>::iterator findit = find(vec.begin(),vec.end(),123);
    //vector<int>::iterator findit = find(vec.begin(),vec.end(),111);
    if(findit==vec.end())
    {
        printf("no find\n");
    }
    else
    {
        printf("find[%d]\n",*findit);
    }
    return 0;
}

這樣的寫法會不會簡單很多呢？
需要說明的是，雖然這個通用的find方法也是可以用在map，set等上面的，但是效率會比容器內部的find方法慢很多，所以，除非容器實在是沒有提供find方法，否則還是建議不要用公共的這一種。

另外，作為題外話，我們需要注意一下vector的刪除(erase)操作。由于vector需要能以下標方式取數據，所以必須時刻保證連續的存儲空間，對應于實現上，即，當刪除vector中間的一個成員時，這個成員后面的所有成員，會以原順序向前全部拷貝過來。有興趣的朋友，可以用這個例子測試一下。
這里起碼告訴了我們兩件事：

1.vector中一個成員被刪除，會導致后面的成員進行copy和析構操作。
2.vector不適合做有大量插入刪除操作的容器，因為拷貝內存本身浪費很大

OK，到此為止啦~

之前寫查找一個VECTOR中保存的一個結構的時候，知道其中的一個數據成員，每次都是遍歷一遍，寫久了覺得好麻煩，覺得不應該是這樣才對。果真在網上找到了這個方法：

用boost::bind，非常簡單：

find_if(v.begin(),v.end(),bind(&A::id,_1)==25);


如果需要，下面是完整示例代碼：

#include   <algorithm>
#include   <vector>
#include   <boost/bind.hpp>

struct   A
{
    int   id;
};

int   main()
{
    using   namespace   std;
    using   namespace   boost;
    vector <A>   v;
    find_if(v.begin(),v.end(),bind(&A::id,_1)==25);
}

//bind用法

// general version
template<class T>
class Compare
{
public:
static bool IsEqual(const T& lh, const T& rh)
{
return lh == rh;
}
};

    這是一個用于比較的類模板，里面可以有多種用于比較的函數， 以IsEqual為例。

    一、特化為絕對類型

    也就是說直接為某個特定類型做特化，這是我們最常見的一種特化方式， 如特化為float， double等

// specialize for float template<> class Compare<float> { public: static bool IsEqual(const float& lh, const float& rh) { return abs(lh - rh) < 10e-3; } }; // specialize for double template<> class Compare<double> { public: static bool IsEqual(const double& lh, const double& rh) { return abs(lh - rh) < 10e-6; } };

    二、特化為引用，指針類型

    這種特化我最初是在stl源碼的的iterator_traits特化中發現的， 如下：

template <class _Iterator> struct iterator_traits { typedef typename _Iterator::iterator_category iterator_category; typedef typename _Iterator::value_type value_type; typedef typename _Iterator::difference_type difference_type; typedef typename _Iterator::pointer pointer; typedef typename _Iterator::reference reference; }; // specialize for _Tp* template <class _Tp> struct iterator_traits<_Tp*> { typedef random_access_iterator_tag iterator_category; typedef _Tp value_type; typedef ptrdiff_t difference_type; typedef _Tp* pointer; typedef _Tp& reference; }; // specialize for const _Tp* template <class _Tp> struct iterator_traits<const _Tp*> { typedef random_access_iterator_tag iterator_category; typedef _Tp value_type; typedef ptrdiff_t difference_type; typedef const _Tp* pointer; typedef const _Tp& reference; };

    當然，除了T*， 我們也可以將T特化為 const T*， T&， const T&等，以下還是以T*為例：

// specialize for T* template<class T> class Compare<T*> { public: static bool IsEqual(const T* lh, const T* rh) { return Compare<T>::IsEqual(*lh, *rh); } };

    這種特化其實是就不是一種絕對的特化， 它只是對類型做了某些限定，但仍然保留了其一定的模板性，這種特化給我們提供了極大的方便， 如這里， 我們就不需要對int*， float*， double*等等類型分別做特化了。

    三、特化為另外一個類模板

    這其實是第二種方式的擴展，其實也是對類型做了某種限定，而不是絕對化為某個具體類型，如下：

// specialize for vector<T> template<class T> class Compare<vector<T> > { public: static bool IsEqual(const vector<T>& lh, const vector<T>& rh) { if(lh.size() != rh.size()) return false; else { for(int i = 0; i < lh.size(); ++i) { if(lh[i] != rh[i]) return false; } } return true; } };

    這就把IsEqual的參數限定為一種vector類型， 但具體是vector<int>還是vector<float>， 我們可以不關心， 因為對于這兩種類型，我們的處理方式是一樣的，我們可以把這種方式稱為“半特化”。

    當然， 我們可以將其“半特化”為任何我們自定義的模板類類型：

// specialize for any template class type template <class T1> struct SpecializedType { T1 x1; T1 x2; }; template <class T> class Compare<SpecializedType<T> > { public: static bool IsEqual(const SpecializedType<T>& lh, const SpecializedType<T>& rh) { return Compare<T>::IsEqual(lh.x1 + lh.x2, rh.x1 + rh.x2); } };

    這就是三種類型的模板特化， 我們可以這么使用這個Compare類：

// int int i1 = 10; int i2 = 10; bool r1 = Compare<int>::IsEqual(i1, i2); // float float f1 = 10; float f2 = 10; bool r2 = Compare<float>::IsEqual(f1, f2); // double double d1 = 10; double d2 = 10; bool r3 = Compare<double>::IsEqual(d1, d2); // pointer int* p1 = &i1; int* p2 = &i2; bool r4 = Compare<int*>::IsEqual(p1, p2); // vector<T> vector<int> v1; v1.push_back(1); v1.push_back(2); vector<int> v2; v2.push_back(1); v2.push_back(2); bool r5 = Compare<vector<int> >::IsEqual(v1, v2); // custom template class SpecializedType<float> s1 = {10.1f,10.2f}; SpecializedType<float> s2 = {10.3f,10.0f}; bool r6 = Compare<SpecializedType<float> >::IsEqual(s1, s2);

    模板有兩種特化，全特化和偏特化（局部特化）

    模板函數只能全特化，沒有偏特化（以后可能有）。

    模板類是可以全特化和偏特化的。

    全特化，就是模板中模板參數全被指定為確定的類型。

    全特化也就是定義了一個全新的類型，全特化的類中的函數可以與模板類不一樣。

    偏特化，就是模板中的模板參數沒有被全部確定，需要編譯器在編譯時進行確定。

    在類型上加上const、&、*（ cosnt int、int&、int*、等等）并沒有產生新的類型。只是類型被修飾了。模板在編譯時，可以得到這些修飾信息。

    模板的特化是非常有用的。它像一個在編譯期的條件判斷。當編譯器在編譯時找到了符合的特化實現，就會使用這個特化實現。這就叫編譯器多態（或者叫靜態多態）。這種東西對編寫基礎庫是很有用的。這也就是為何c++的基礎庫大量使用了模板技術，而且大量使用了特化，特別是偏特化。

    在泛型中，利用特化類得到類新的特性，以便找到最適合這種特性的實現。而這一切都是在編譯時完成。

C++箴言：理解typename的兩個含義　　問題：在下面的 template declarations（模板聲明）中 class 和 typename 有什么不同？ 　　答案：沒什么不同。在聲明一個 template type parameter（模板類型參數）的時候，class 和 typename 意味著完全相同的東西。一些程序員更喜歡在所有的時間都用 class，因為它更容易輸入。其他人（包括我本人）更喜歡 typename，因為它暗示著這個參數不必要是一個 class type（類類型）。少數開發者在任何類型都被允許的時候使用 typename，而把 class 保留給僅接受 user-defined types（用戶定義類型）的場合。但是從 C++ 的觀點看，class 和 typename 在聲明一個 template parameter（模板參數）時意味著完全相同的東西。

　　然而，C++ 并不總是把 class 和 typename 視為等同的東西。有時你必須使用 typename。為了理解這一點，我們不得不討論你會在一個 template（模板）中涉及到的兩種名字。

　　假設我們有一個函數的模板，它能取得一個 STL-compatible container（STL 兼容容器）中持有的能賦值給 ints 的對象。進一步假設這個函數只是簡單地打印它的第二個元素的值。它是一個用糊涂的方法實現的糊涂的函數，而且就像我下面寫的，它甚至不能編譯，但是請將這些事先放在一邊——有一種方法能發現我的愚蠢： 　　我突出了這個函數中的兩個 local variables（局部變量），iter 和 value。iter 的類型是 C::const_iterator，一個依賴于 template parameter（模板參數）C 的類型。一個 template（模板）中的依賴于一個 template parameter（模板參數）的名字被稱為 dependent names（依賴名字）。當一個 dependent names（依賴名字）嵌套在一個 class（類）的內部時，我稱它為 nested dependent name（嵌套依賴名字）。C::const_iterator 是一個 nested dependent name（嵌套依賴名字）。實際上，它是一個 nested dependent type name（嵌套依賴類型名），也就是說，一個涉及到一個 type（類型）的 nested dependent name（嵌套依賴名字）。

　　print2nd 中的另一個 local variable（局部變量）value 具有 int 類型。int 是一個不依賴于任何 template parameter（模板參數）的名字。這樣的名字以 non-dependent names（非依賴名字）聞名。（我想不通為什么他們不稱它為 independent names（無依賴名字）。如果，像我一樣，你發現術語 "non-dependent" 是一個令人厭惡的東西，你就和我產生了共鳴，但是 "non-dependent" 就是這類名字的術語，所以，像我一樣，轉轉眼睛放棄你的自我主張。）

　　nested dependent name（嵌套依賴名字）會導致解析困難。例如，假設我們更加愚蠢地以這種方法開始 print2nd：
　　這看上去好像是我們將 x 聲明為一個指向 C::const_iterator 的 local variable（局部變量）。但是它看上去如此僅僅是因為我們知道 C::const_iterator 是一個 type（類型）。但是如果 C::const_iterator 不是一個 type（類型）呢？如果 C 有一個 static data member（靜態數據成員）碰巧就叫做 const_iterator 呢？再如果 x 碰巧是一個 global variable（全局變量）的名字呢？在這種情況下，上面的代碼就不是聲明一個 local variable（局部變量），而是成為 C::const_iterator 乘以 x！當然，這聽起來有些愚蠢，但它是可能的，而編寫 C++ 解析器的人必須考慮所有可能的輸入，甚至是愚蠢的。

　　直到 C 成為已知之前，沒有任何辦法知道 C::const_iterator 到底是不是一個 type（類型），而當 template（模板）print2nd 被解析的時候，C 還不是已知的。C++ 有一條規則解決這個歧義：如果解析器在一個 template（模板）中遇到一個 nested dependent name（嵌套依賴名字），它假定那個名字不是一個 type（類型），除非你用其它方式告訴它。缺省情況下，nested dependent name（嵌套依賴名字）不是 types（類型）。（對于這條規則有一個例外，我待會兒告訴你。）

　　記住這個，再看看 print2nd 的開頭：
　　這為什么不是合法的 C++ 現在應該很清楚了。iter 的 declaration（聲明）僅僅在 C::const_iterator 是一個 type（類型）時才有意義，但是我們沒有告訴 C++ 它是，而 C++ 就假定它不是。要想轉變這個形勢，我們必須告訴 C++ C::const_iterator 是一個 type（類型）。我們將 typename 放在緊挨著它的前面來做到這一點：
　　通用的規則很簡單：在你涉及到一個在 template（模板）中的 nested dependent type name（嵌套依賴類型名）的任何時候，你必須把單詞 typename 放在緊挨著它的前面。（重申一下，我待會兒要描述一個例外。）

　　typename 應該僅僅被用于標識 nested dependent type name（嵌套依賴類型名）；其它名字不應該用它。例如，這是一個取得一個 container（容器）和這個 container（容器）中的一個 iterator（迭代器）的 function template（函數模板）：
　　C 不是一個 nested dependent type name（嵌套依賴類型名）（它不是嵌套在依賴于一個 template parameter（模板參數）的什么東西內部的），所以在聲明 container 時它不必被 typename 前置，但是 C::iterator 是一個 nested dependent type name（嵌套依賴類型名），所以它必需被 typename 前置。

　　"typename must precede nested dependent type names"（“typename 必須前置于嵌套依賴類型名”）規則的例外是 typename 不必前置于在一個 list of base classes（基類列表）中的或者在一個 member initialization list（成員初始化列表）中作為一個 base classes identifier（基類標識符）的 nested dependent type name（嵌套依賴類型名）。例如：
　　這樣的矛盾很令人討厭，但是一旦你在經歷中獲得一點經驗，你幾乎不會在意它。

　　讓我們來看最后一個 typename 的例子，因為它在你看到的真實代碼中具有代表性。假設我們在寫一個取得一個 iterator（迭代器）的 function template（函數模板），而且我們要做一個 iterator（迭代器）指向的 object（對象）的局部拷貝 temp，我們可以這樣做：
　　不要讓 std::iterator_traits<IterT>::value_type 嚇倒你。那僅僅是一個 standard traits class（標準特性類）的使用，用 C++ 的說法就是 "the type of thing pointed to by objects of type IterT"（“被類型為 IterT 的對象所指向的東西的類型”）。這個語句聲明了一個與 IterT objects 所指向的東西類型相同的 local variable（局部變量）(temp)，而且用 iter 所指向的 object（對象）對 temp 進行了初始化。如果 IterT 是 vector<int>::iterator，temp 就是 int 類型。如果 IterT 是 list<string>::iterator，temp 就是 string 類型。因為 std::iterator_traits<IterT>::value_type 是一個 nested dependent type name（嵌套依賴類型名）（value_type 嵌套在 iterator_traits<IterT> 內部，而且 IterT 是一個 template parameter（模板參數）），我們必須讓它被 typename 前置。

　　如果你覺得讀 std::iterator_traits<IterT>::value_type 令人討厭，就想象那個與它相同的東西來代表它。如果你像大多數程序員，對多次輸入它感到恐懼，那么你就需要創建一個 typedef。對于像 value_type 這樣的 traits member names（特性成員名），一個通用的慣例是 typedef name 與 traits member name 相同，所以這樣的一個 local typedef 通常定義成這樣：
　　很多程序員最初發現 "typedef typename" 并列不太和諧，但它是涉及 nested dependent type names（嵌套依賴類型名）規則的一個合理的附帶結果。你會相當快地習慣它。你畢竟有著強大的動機。你輸入 typename std::iterator_traits<IterT>::value_type 需要多少時間？

　　作為結束語，我應該提及編譯器與編譯器之間對圍繞 typename 的規則的執行情況的不同。一些編譯器接受必需 typename 時它卻缺失的代碼；一些編譯器接受不許 typename 時它卻存在的代碼；還有少數的（通常是老舊的）會拒絕 typename 出現在它必需出現的地方。這就意味著 typename 和 nested dependent type names（嵌套依賴類型名）的交互作用會導致一些輕微的可移植性問題。

　　Things to Remember

　　·在聲明 template parameters（模板參數）時，class 和 typename 是可互換的。

　　·用 typename 去標識 nested dependent type names（嵌套依賴類型名），在 base class lists（基類列表）中或在一個 member initialization list（成員初始化列表）中作為一個 base class identifier（基類標識符）時除外

上層涉及到網絡消息時，多線程的問題需要時時注意。OnRecv、OnClose等消息的調用是在網絡線程中，而不是邏輯線程；如果需要在處理網絡消息時進行邏輯操作，就一定要對多個線程都涉及到的變量加鎖。在邏輯復雜的環境（如邏輯服務器），把所有變量加鎖是不現實的，較簡單的一種解決方法是把網絡消息緩存起來，然后在邏輯線程的定時更新函數里處理這些緩存的消息。這樣，需要加鎖的只有這個緩存
（待續）

新公司沒有WIKI，只有項目管理的redmine，所以想記錄點東西還比較麻煩，所以我決定在自己的機器上配置一下PHP的環境，裝上WORDPRESS，充當WIKI用。而且導入導出也很方便，省掉了因為網絡不好寫blog的窩火和鬧心。

1.apache安裝，沒啥說的 一路NEXT就可以了。
2..php安裝，選擇版本的時候要注意下
VC6 版本是使用 Visual Studio 6 編譯器編譯的，如果你是在windows下使用Apache+PHP的，請選擇VC6版本
VC9 版本是使用 Visual Studio 2008 編譯器編譯的，如果你是在windows下使用IIS+PHP的，請選擇VC9版本
所以選擇VC6的版本

3.關鍵是兩個配置php.ini 和httpd.conf

httpd.conf
1.DocumentRoot(網站的根目錄)改成自己的,注意 "\"要改成 "/"
2.DirectoryIndex(目錄索引) 添加index.php
3.LoadModule php5_module G:/WEB/php/php5apache2_2.dll
   PHPIniDir "G:/WEB/php"
4.AddType application/x-httpd-php .php AddType application/x-httpd-php .html

php.ini
1.extension:mysql前面的分號去掉
2.d:/php d:/php/ext 目錄添加到環境變量里

MySql如果之前有裝過的話，可能會出現問題cannot create windows service for mysql.error:0
這樣只需要刪除MYSQL服務
cmd下：執行 sc delete mysql
也可以把MySql的服務名該一下也OK

 http://blog.163.com/liuyuelin007@126/blog/static/213387692007411151568/

http://blog.csdn.net/lychee007/archive/2009/05/31/4227419.aspx

http://social.microsoft.com/Forums/es-ES/visualcpluszhchs/thread/ff6ddac2-a69d-4c02-ad20-d73cb4335c24

http://hi.baidu.com/237rxd/blog/item/35a51efa18e098859e5146b9.html

http://topic.csdn.net/t/20050712/20/4140158.html

     摘要: 看到首頁上有人寫，自己也寫了一個名字起錯了，其實寫個stack更合適 //!Node information//!struct Node{    int serialNumber;    int flag;    struct ...  閱讀全文

不少筆試題都把這三個函數放一起比較，其實他們三個沒啥可比性，就是三個不同的函數而已

Memset 用來對一段內存空間全部設置為某個字符，一般用在對定義的字符串進行初始化為‘ ’或‘\0’；

主要應用是初始化某個內存空間

例:char a[100];memset(a, '\0', sizeof(a));

memset可以方便的清空一個結構類型的變量或數組。

如：

struct sample_struct
{
 char   csName[16];
 int    iSeq;
 int    iType;
};

對于變量
struct sample_strcut  stTest;

一般情況下，清空stTest的方法：

stTest.csName[0]='\0';
stTest.iSeq=0;
stTest.iType=0;

用memset就非常方便：
memset(&stTest,0,sizeof(struct sample_struct));

如果是數組：

 struct sample_struct   TEST[10];
則
memset(TEST,0,sizeof(struct sample_struct)*10);

memcpy 用來做內存拷貝，你可以拿它拷貝任何數據類型的對象，可以指定拷貝的數據長度。

memcpy是用于copy源空間的數據到目的空間中
例：char a[100],b[50]; memcpy(b, a, sizeof(b));注意如用sizeof(a)，會造成b的內存地址溢出。

Strcpy   就只能拷貝字符串了，它遇到'\0'就結束拷貝。

例：char a[100],b[50];strcpy(a,b);如用strcpy(b,a)，要注意a中的字符串長度（第一個‘\0’之前）是否超過50位，如超過，則會造成b的內存地址溢出。

strcpy用于字符串copy,遇到‘\0’，將結束