考慮如下代碼：

#include <iostream>
using namespace std;

int main()
{
  int a;
  while(cout<<"input a integer (1- 10) :",cin>>a,! (a>=1 && a<=10))
   cout<<"try again!"<<endl;
return 0;
}

本意是讓用戶選擇一個1-10的數，如果不是1-10的數則重新輸入。

分析：

如果用戶輸入了一個不在1-10的 int，那么，程序會正確的執行，并且提示用戶重新輸入。

但是如果用戶錯誤的輸入了一個字符char，那么，后果就是一直執行while循環！

錯誤分析：

當cin嘗試將輸入的字符讀為int型數據失敗后，會產生一個錯誤狀態--cin.fail().而要用cin讀取輸入流中的數據，輸入流必須處于無錯誤狀態。因此，由于錯誤狀態的存在，會一直執行while循環。

錯誤修正：

#include <iostream>
using namespace std;

int main()
{
int a;
while(cout<<"input a integer (1-10) :",cin>>a,! (a>=1 && a<=10) || cin.fail())
{
   cout<<"try again!"<<endl;
   cin.clear(); //清除std::cin的錯誤狀態
   cin.sync(); //清空輸入緩沖區
}
return 0;
}

加上判斷輸入是否成功的cin.fail()以及修正錯誤輸入的cin.clear()和cin.sync();

其中std::cin.sync();這一句必不可少，因為所有從標準輸入設備輸入的數據都是先保存在緩沖區中，然后istream對象再從緩沖區中進行提取。如果不清空緩存，下次在讀取數據的時候又會再次產生錯誤，也會陷入死循環。

    題記：一直以來都被一些細節忽略了，然后，遇到很多的問題就杯具了……從現在開始，覺得很有必要從小事做起，認真的來看看曾經犯過的錯誤，做過的事情。特別是對于曾經以為很習以為常的事情，要特別的重視，于是便有了tips，下面不斷的更新中…………

題外話：（如何在Office 2007中創建并發布博文？）今天發現可以在Word 2007中編輯博客，然后直接點擊發布，就可以發布到C++博客網上了，很貼心的服務，不是嗎？其實這個也是Office的一個功能，在新建中，點擊新建博客文章，就可以創建一個新的blog，然后會提示你創建一個賬戶，估計這個是最關鍵的，需要選擇其他運營商，然后下一步，會有個API讓你選擇，選擇下面的按個MetaWebLog，然后輸出你的賬號密碼，這里的昂URL，不是你的主頁的，開始的時候我也是選擇這個，錯誤，連接不上。需要的是：在你的主頁上，點擊管理，然后點擊選項，下面有個configure選項，進入后，最下面就有一個你的那個URL了，添加進去，OK！然后就可以發布了！

下面開始正式的tips：

1. int到底占用多少個字節？

   一直以來都被這個問題糾結，因為上過匯編和C的課，然后又看了《C++ Primer》一書，總是會出現各種的不一致，如果按照平時我們的認為，都是4個Byte（字節），可是無奈很多書上講解不一致，所以造成了迷惑……今天找時間上網搜了下，發現答案很多，不過大致上都是一個解答，于是我也就憑借自己的思考，來說說了。

   答：首先摘錄網上的朋友們的留言：

綜合上面的說法，我也覺得對于int到底占用多少個字節，其實是和機器以及編譯器都有關系。這么來說吧，我覺得機器起決定性作用，如果是32位機，那么在這個平臺上面運行的編譯器，可以使32位版本的，也可以是16位版本的（向下兼容，只不過浪費了好機子，沒有充分發揮效果），這也就是說我們在網上下載驅動的時候，有時候會發現官網上面有32位操作系統Windows版本和64位操作系統Windows的不同分類了。而決定這個位數的，就是你的CPU，也就是機器。

但是，編譯器沒有必要一定要這么做，對于TC 2.0這樣的16位軟件，曾經在Dos下呼風喚雨，但是到了32位機下，仍然是可以用的，這樣的話，也就是說，它運算的結果是2個字節，可是因為軟件的限制，只能夠模擬出來16位機，所以雖然可以在32位上面跑，但是不能反映實際的字長。但是，沒有多少人會在32位機子上面模擬出128位或者64位，因為這樣尋址的話效率很低下，硬件條件沒有達到，利用軟件來模擬是不夠的。于是，就是上面的那種說法。由于VC以及其他軟件更新很快，而且及時開發了Win 32下的版本，所以是32位軟件，也就是說，它計算處理的int是4個字節。

當然，我們需要知道的是，標準并沒有規定int一定要是多少個字節，而只是規定了一個范圍，只要你不越軌，那么肯定就沒有問題，至于實現，那是你編譯器的開發的事情，跟我無關。同樣，CPU和機器的制造者，關心的是如何提高計算機的性能，讓尋址方式更大，范圍更長，也就是位數越多，（這也是為何目前的那些機器都朝著64位或者更高位發展的目的），而軟件開發者，面臨的則是需要來適應硬件的更新，從而做出更好的軟件，充分利用到這個性能。

當然，這個問題本身沒有多少討論的價值，不過，如果在面試或者考試中，遇到sizeof的操作，最好問清楚是在32位機子下還是16位或者是64位，這個能夠反映你的嚴謹和認真。

注： 32位下：1int = 4 Byte            16位下：1 int = 2B        (當然，一般都不會考慮那個TC 2.0的)

2).普通類的繼承中，如果派生類中的函數和基類函數同名時，是否會覆蓋原來的那個函數？

    在java中，很明顯是會覆蓋的，因為繼承的特性，注意同名函數，要求還有原型相同，否則的話，調用的時候是可以區分開來的，而當原型相同的時候，那么派生類會繼承基類的函數，同時由于有一個自己的函數，所以兩個同名，同原型的函數，是會發生覆蓋的。

上代碼看之：

輸出的結果是：

從上面的結果可以看到，派生類的指針是調用派生類的對應的函數，配套的，而且還選擇作用域較小的，而這樣的優先級就要高些。這里有一個強制類型轉換，因為是要將派生類的指針指向基類的對象，會發生截斷，所以一定要強制類型轉換，與此對比的是，基類的指針指向派生類的話不需要強制類型轉換也可以實現。從結果可以看到，如果實行了轉換，那么還是聲明時候的類型，所以抓住了這點，聲明時是B類型的，那么就調用B的moveto，所以輸出時2，下面的另外一些的輸出，就都是1了，也可以看到，如果要顯示的調用被隱藏的基類，需要用作用域限定符來指示。

 2.隱藏的this指針不是實際的一個參數，也就是說，實際調用函數中，不能夠使用這個參數。
上代碼：

#include <string.h>
#include <iostream>
using namespace  std;

class STRING{
    char *str;
public:
    STRING(char *s=0);
    STRING(const STRING &);
    virtual int strlen(void) const;
    virtual int strcmp(const STRING &) const;
    virtual STRING &operator+(const STRING &);
    virtual STRING &operator=(const STRING &);
    virtual STRING &operator+=(const STRING &);
    virtual operator const char *(void) const;
    virtual ~STRING();
};

STRING::STRING(char *s/**//*=0*/){
    str = new char[::strlen(s)+1];
    ::strcpy(str,s);
}
STRING::~STRING(){
    delete str;
}
int STRING::strlen(void) const{
    return ::strlen(this->str)+5; //采用字符串的通用表示，不含null
}
int STRING::strcmp(const STRING &b) const{
    return ::strcmp(this->str,b.str);
}
STRING &STRING::operator+(const STRING &b){
    ::strcat(this->str,b.str);
    return *this;
}
STRING &STRING::operator=(const STRING &b){
    this->str = b.str;
    return *this;
}
STRING &STRING::operator+=(const STRING &b){
    ::strcat(this->str,b.str);
    return *this;
}
STRING::operator const char *(void) const{
    return this->str;
}
int main()
{
    STRING s("Hello,world");
    STRING e("I Love C++");
    cout << "STRING:" << s << "\t strlen:" << s.strlen()<< endl;
    cout << "STRING:" << e << "\t strlen:" << strlen(e)<< endl;
    
    return 0;

}

  僅僅看輸出，前面的一個是調用類函數strlen，沒有參數，看到沒有，如果有參數的話，就是下面的那個，那么此時就是調用的系統函數了。兩者的輸出不一樣，我特意在自定義的strlen函數上面加5以表示區別，最后果然，前者就是調用自己的函數。
得到的結論就是，類的成員函數，都是有一個默認的this指針的，這個沒有錯，不過這個是編譯器加的，我們手動是不能自己占有的，也就是說不能理解為有一個參數，然后放上面去，自己定義的是void參數，就沒有參數，編譯器加的是它的事情，那個地方提供給我們用戶使用的就是無參的函數。此點要銘記，而且，即使你調用無參的，在具體編譯器處理的時候，還是會給你加上，所以這部分你根本用不上，也不需要擔心。

在C++中，如果出現函數的形參和類的數據成員同名的情況，一定不要為了圖簡省而使用下面的寫法。例：

在紅色部分突出顯示的就是錯誤的寫法，實際上，形參的值根本沒有傳入到這個函數中，而在你輸出的時候，根本沒有x，y的值，也就是一個隨機的。說明形參根本沒有傳入。

這個也是Java中遇到的，如果有這種情況，java中用到的是this引用來顯示的圈定范圍，而C++中，也需要用this指針來顯示的解決這個問題。或者用作用域限定符來解決。

更改后才會出現正確的結果，而以前，自己一直都沒有注意到。

為何會這樣呢？因為按照范圍從小到大的順序，形參的范圍更小，所以替換的就是恒等式，那么自然不會顯示的來給成員賦值，因為類的成員作用范圍更小，此處，要謹記。

而且對于Java也是一樣，都要顯示的來指出。

a.       常量型成員變量

b.       引用型成員變量

c.        靜態成員變量

d.       整型靜態常量成員變量

e.       非整型靜態常量成員變量

對于常量型成員變量和引用型成員變量的初始化，必須通過構造函數初始化列表的方式進行。在構造函數體內給常量型成員變量和引用型成員變量賦值的方式是行不通的。

靜態成員變量的初始化也頗有些特別。

參考下面的代碼以及其中注釋：

// Initialization of Special Data Member

#include <iostream>

using namespace std;

class BClass

{

public:

         BClass() : i(1), ci(2), ri(i)   // 對于常量型成員變量和引用型成員變量，必須通過

         {                                             // 參數化列表的方式進行初始化。在構造函數體內進

         }                                             // 行賦值的方式，是行不通的。

         void print_values()

         {

                   cout << "i =\t" << i << endl;

                   cout << "ci =\t" << ci << endl;

                   cout << "ri =\t" << ri << endl;

                   cout << "si =\t" << si << endl;

                   cout << "csi =\t" << csi << endl;

                   cout << "csi2 =\t" << csi2 << endl;

                   cout << "csd =\t" << csd << endl;

         }

private:

         int i;                                                          // 普通成員變量

         const int ci;                                             // 常量成員變量

         int &ri;                                                      // 引用成員變量

         static int si;                                             // 靜態成員變量

         //static int si2 = 100;                             // error: 只有靜態常量成員變量，才可以這樣初始化

         static const int csi;                                // 靜態常量成員變量

         static const int csi2 = 100;                  // 靜態常量成員變量的初始化(Integral type)    (1)

         static const double csd;                      // 靜態常量成員變量(non-Integral type)

         //static const double csd2 = 99.9;      // error: 只有靜態常量整型數據成員才可以在類中初始化

};

// 靜態成員變量的初始化(Integral type)

int BClass::si = 0;

// 靜態常量成員變量的初始化(Integral type)

const int BClass::csi = 1;

// 靜態常量成員變量的初始化(non-Integral type)

const double BClass::csd = 99.9;

// 在初始化(1)中的csi2時，根據Stanley B. Lippman的說法下面這行是必須的。

// 但在VC2003中如果有下面一行將會產生錯誤，而在VC2005中，下面這行則可有可無，

// 這個和編譯器有關。

const int BClass::csi2;

int main(void)

{

         BClass b_class;

         b_class.print_values();

         return 0;

}

本文來自CSDN博客，轉載請標明出處：http://blog.csdn.net/pathuang68/archive/2009/11/25/4867323.aspx

C/C++中的字符串字面值

1.     字符串數組的大小如何得到。我們都知道，對于一個字符串數組，要得到它的大小，有多種辦法，常見的有下面的兩種。

Ⅰ.利用sizeof運算符來實現。現在假設有一個字符數組str[] = “hello,world”,為了得到的它的長度，我們利用這種辦法

具體就是sizeof(str) /sizeof(char);結果是12，比較發現，實際的字符串大小事11啊，為什么會得到12的結果呢？

有這種疑問，是因為對我們字符數組沒有一個更好的理解。上面初始化一個字符數組，是利用字符串來初始化的，

而字符串的話，默認的是會有一個以null結尾的標志，這個具體的就是’\0’,有很多人的程序有問題，可能都是因為這里

出現了問題，比如數組沒有封口，造成了指針非法訪問其他內存單元，等等。所以實際上的長度就是12.

具體來說說這個原理吧：sizeof是表示計算大小，即字節數。這里以一個數組名來作為參數，就是計算這個數組的大小。

上面說到，字符串數組的話是有一個默認的null來封口的，所以，計算的大小事包括這個單元的。于是sizeof(str)的大小

就是12 個字節，然后計算一個單元，即一個字符char類型的占據的字節數，也就是1個字節，兩者相除，就是12的結果。

Ⅱ.利用循環來實現，這個部分是很多人都常常想到的。因為一個字符串來定義的數組，默認是以null即為的，所以，通過               循環遍歷的方式來實現，這個方法還是可行的。定義一個變量i，然后利用for循環，判斷str[i]不為’\0’，即可判斷              得到最后一個元素的下標，注意到的是這里是最后一個字符元素，但是不是最后一個真正的元素，有一個null，因此，還                要加上1才是真正的個數，經過這個過程，得到的就是總的長度。這個方法比較容易理解。但是容易忽略了最后一個的作用。                                                                                                實際上，我們使用的很多C提供的函數，關于字符串操作的，都需要用到這個知識，我們在做計算的時候，很容易誤以為返                    回的。就是那個字符串的長度，從而導致了錯誤。實際在我們拷貝字符串的時候，尤其要注意這一點。

2.  在《C++ Primer》一書中，將以null結束的字符數組稱為字符數組，標準庫提供一批處理這類字符數組的函數，包括strlen,strcmp,strcat,strcpy,strncat,strncpy等等，而這些函數中的參數，都是以null結束的字符數組名，也就是字符數組的指針，而得到長度，返回的就是一個長度，沒有包括null這個單元，所以實際上，上面的那個還有一個方法，可以調用此函數來實現。當然，還有一點要注意的是，strcat連接函數，將右邊的字符串連接到左邊，所以對于左邊的字符串，一定要準確的計算出長度，如果不慎，就會溢出，出現嚴重的錯誤。看看下面這個例子：

Char s1[25] = “hello,world”;  char s2[20] = “0123456789012345678”(剛好是20個字符，為何，因為有一個null).所以現在的那個s2[20] = “01234567890123456789”,此時你會發現，字符串就有20個，含有一個null，注意就溢出了，OK。

下面，如果我將上面的那個采用字符串連接函數來做，就是strcat(s1,s2)，那么又會出現錯誤。因為溢出了。

3.C++中提供了一個標準庫string來處理字符串，這個string類提供了很多操作，是一種更安全的做法，然而了，為了新舊代碼的兼容，需要進行兩者之間的轉換，而把string的一個類函數c_str()返回值是C風格字符串。const char *str = st2.c_str();其中st2是一個string類型的對象，返回值就是一個指向它的字符串。 此即為字符串的處理，作為C/C++的字符串值得注意的地方。                                                 

1．操作系統的實驗基本上都是以linux下面的系統編程為內容，進程的調度和創建都是很基本的內容。很幸運的是，linux為我們提供了很多的系統函數，供我們來使用。通過熟悉這些函數，使得我們可以能夠對進程和程序有一個更良好的認識。

2．Fork函數的使用。下面引用自百度百科：

1.      下面來詳細的說說我的程序和問題，通過比較學習，相信對于linux的學習，特別是進程和程序直接的關系有一個更好的理解。

Process2.c

Code：

#include <stdio.h>

#include <unistd.h>

int main()

{

 int p1;

 p1=fork();

 if (p1 == 0)      //子進程，輸出它的父進程和當前進程的PID

 {

     printf("current PID is %d\n",getpid());

     printf("father PID is %d\n",getppid());

     printf("\n");

 }

 else   //這里是父進程嗎？

 {

     printf("father PID is %d\n",getppid());

     printf("current PID is %d\n",getpid());

     printf("\n");

 }

 return 0;

}

分析：此進程的運行結果是？（思考后再回答）

是的，有兩種情況。首先，程序運行到fork語句之后，創建進程，此時有兩種情況，創建成功和不成功，而成功又有兩種情況，fork的返回值為0，則運行的是創建的子進程，fork的返回值為1，則運行的是父進程。用if語句來判斷，OK。

那么問題就是，if語句中沒有問題，p1為0，說明創建成功，運行的是子進程，可是else語句來說，卻又兩種情況，如果創建不成功也在else語句中，那么此時當前進程就是那個原始的進程，而它的父進程卻是1號PID，因為所有的進程都是1號進程的子進程，這個是linux下面的結論。操作系統的知識。

所以，此時的結果應該是：

先放著，先解釋下面的這個，注意，這個對上面是有幫助的。

（看完之后回頭過來看看），看到沒有，首先輸出的那個father PID是什么，剛好就是下面的那個32667，這個不是偶然的，說明什么，當然，這個進程就是父進程，而創建它的那個進程的PID是32667，可以認為是系統創建的。就是說這種情況下面是，先運行的父進程。而它創建失敗了，那么它沒有子進程啊，那么那個下面的這個進程的父進程就不是上面的那個了，為何，從結果可以看到，它的PID是1，而不會是15254，說明不是上面的那個創建。而創建卻是1，說明是系統創建的，所以fork語句之后，沒有創建成功，而是由系統來親自創建一個進程，所以PID號當然是下一個，不過父進程就是1號了。（有興趣的可以查閱下資料，我們也是剛學，所以我還有繼續探究中！！）

PID = 13501 父進程

PID = 13504 子進程

系統創建了當前的那個父進程，就是程序運行的進程 PID = 32667

 

下面還想討論這樣一個問題，這個問題是從上面那個第一種情況引申來的。

如下：

Code：

結果如下，雖然比較多，不過很能說明問題：

看完了上面的那個例子，下面的這個例子就是小case了，當然，其實上面的那個例子就是由下面的這個例子引申來的，是因為寫錯了代碼而引起的。當然，根據錯誤，我們收獲不小啊！

Code：

結果如下：

因為我們希望使用到類的一些操作，使得一個類更像內置的數據類型（int，float…………）

比如說對于int類型的變量，自增運算符是默認的，即定義int i，即可以用到i++，而現在對于自定義

的一個類，如果沒有定義++操作，那么程序時不會找到這個操作的相應定義的，更不會執行相應的操

作！

也就是說，實際上重載運算符是給了++…………這些運算符一些新的定義和操作，結果很明顯，我們

使用自定義類的時候可以像內置類型一樣那么自然，簡單，符合我們的用戶習慣！

2.如何定義重載運算符？

前面說到重載，對，對于一個運算符，實際上語言的本身是定義默認的操作的，比如說加法運算，對于int類型可以知道是整數相加，對于float類型也是如此，這實際上也是一種重載，對于不同類型的數據，可以用同一個運算符來重載！

現在我們的問題是要增加自己定義的類的操作。

OK，言歸正傳，有兩種定義的方法，使用類內置成員函數的方法和友元的方法來定義：

運算符的重載形式有兩種：重載為類的成員函數和重載為類的友元函數。

總括：此部分寫的還是比較好，特別是第一章，介紹了面向對象編程的特別，關鍵是從一個解決問題的角度來分析，相比較而言，C++ Primer更顯得雜亂無章。通過對問題深入，根據解決問題的方法，來實現最合理化的得到目的，從而引出繼承等等一系列概念和手段。

1.     構造器

2.     繼承的細節

對于類的幾點認識：
---------《以下的幾條規范是便于多文件管理，分別編譯的》---------
1.將類的聲明放在h文件中，注意是聲明，而不是定義，命名之，最好用類

名來給這個h文件命名。
2.將類的定義放在cpp文件中，單獨一個cpp文件中，以類名命名之。
3.將主函數放在單獨一個文件cpp中，文件名無所謂，不過取main的話便于

找到主體程序在哪里。

下面要說的是虛函數：virtual
1.在類中要聲明virtual，但是放在對應的定義cpp文件中的時候，要注意去

掉virtual，否則會報錯。
2.注意聲明和定義的原型都必須完全一樣，比如聲明中有一個const，那么

在定義中必須也要有，否則的話就會報錯，說不認識這個函數。
3.在類外定義的話一定要加上類型限定符，作用域限定符。

 下面寫點代碼：

student.h頭文件 
1#ifndef STUDENT_H
 2#define STUDENT_H
 3
 4#include <iostream>
 5using std::string;
 6
 7
 8class Student
 9{
10public:
11    Student(const string& a="",double b=0.0,int c=0):score(b),name(a),number(c)
12    {}
13    ~Student(){}
14    //void show_score();
15    //void modify(Student& a);
16    friend Student operator+(Student& a,Student& b);
17    friend Student operator-(Student& a,Student& b);
18    friend std::ostream& operator<<(std::ostream &a,Student& b);  //改變狀態的一般都要定義為類成員，++，--及*
19    friend std::istream& operator>>(std::istream &a,Student& b);//進行算術運算和輸入輸出的就定義為友元
20    //Student& operator=(Student& a);
21private:
22    double score;
23    string name;
24    int number;
25};
26
27#endif

 1student.cpp文件，實現類函數
 2#include <iostream>
 3#include <string>
 4#include "Student.h"
 5using std::cout;
 6using std::cin;
 7using std::endl;
 8
 9Student operator+(Student& a,Student& b) //這里面又用到了<<這個運算符的。而這個你已經自定義了啊！
10{
11    cout << a.name << "和" << b.name << "分數之和為:" << a.score+ b.score;
12    cout << endl;
13    return a;
14}
15Student operator-(Student& a,Student& b)
16{
17    cout << a.name << " 比 " << b.name << "多" << 
18        (a.score > b.score)?(a.score-b.score):(b.score - a.score);
19    cout << endl;
20    return a;
21}
22std::ostream& operator<<(std::ostream &a,Student& b)
23{
24    a << b.name<<"的分數：" << b.score << "\t 學號：" << b.number << endl;
25    return a;
26}
27std::istream& operator>>(std::istream &a,Student& b)
28{
29    a >> b.name >>b.number >> b.score  ; 
30    return a;
31}
32/**//*
33問題1，修改定義函數的時候沒有修改聲明，為什么這么粗心呢？
342.返回值，特別是對于有輸入輸出流的，要有返回值啊！
353.流的返回值和調用。
364.返回值怎么能為void呢？因為要輸出a+b，所以要返回一個值啊，相當于opreator+(a,b)
37*/

主函數：main.cpp 
1#include <iostream>
 2#include "Student.h"
 3
 4using namespace std;
 5
 6int main()
 7{
 8    Student a,b;
 9    cout << "依次輸入姓名，學號，成績" << endl;
10    cin >> a >> b;
11    cout << a << b;
12    cout << endl;
13    return 0;
14}
15

 我想說的是自己遇到的幾個問題：
1.重載<< 和>>操作符：這兩個操作符只能作為友元而不是成員函數。作為重載運算符，有兩種定義形式，即：成員函數形式和非成員函數形式，對于成員函數的形式，它的聲明方式是形參數要比操作數少一個，為什么呢，因為省略了默認的形參this指針，而這個省略的形參正式左操作數，即定義這樣的運算符的時候，this指針指向的是左操作數。其次，就是非成員函數，即友元聲明方式。友元聲明方式較簡單合理，形參數和操作數相同，顯示的是合理的調用函數的方式。
2.什么時候用成員函數的聲明方式，什么時候用友元函數的聲明方式？此部分需注意的是：1，對于=，（），【】，->這四個操作符只能作為成員函數來聲明，想想這個是為什么呢？
  (1)只能使用成員函數重載的運算符有：=、()、[]、->、new、delete。
  (2)單目運算符最好重載為成員函數。
  (3) 對于復合的賦值運算符如+=、-=、*=、/=、&=、!=、~=、%=、>>=、<<=建議重載為成員函數。
  (4) 對于其它運算符，建議重載為友元函數。
關于此問題的詳細討論，見：http://www.rupeng.com/forum/thread-4468-1-1-uid3573.html
在C++編程思想中有述，據網友而言，大意是：如果可以定義為全局變量的話，那么就可以定義為int operator =(int,mytype),而這種方式的話就不對了，因為賦值=是和左邊的類緊密相連的，所以會定義為成員函數的……

 此部分詳細關注中………………

3.關于重載運算符的返回值的問題：
我們是不是已經習慣于重載運算符有一個返回值類型呢？對，是的，我們經常這么干，現在的問題是，如果我定義為void的話，會出錯嗎？
不會的，將上面的換成void的返回值照樣不會出錯！
為什么呢？因為定義有返回值只是我們的一個習慣，為何有返回值，因為我們要返回值，很白癡吧？可是事實就是這樣，想想這個：
cout << a + b;  這個代碼很簡單是吧，a+b 實際上就是operator+（a,b）的一個等價形式,我要能夠cout ，那么必然有一個返回值，否則的話調用這個函數沒有返回值的話我怎么cout它呢？于是乎我們在定義加法的重載的時候就只能在前面加上a和b的類型了。
好，現在我沒有類型了，void，怎么辦？很簡單，直接用 a + b;  因為它相當于：operator+(a,b);也就是調用一個函數，直接調用，沒有返回值。
當然，結果也還是對的，各位可以看看…………

注意我想說的，學習計算機主要的是學習那個思想，而不是片面的記住語法或者其他，要想想為什么需要這樣，這樣我們的思維才會和計算機接近，才能更好的理解計算機，上面的這個例子就是很好的說明，這個函數很另類了吧，可是它完全符合各種語法，能夠順利運行。。
可是要記住的是，重載運算符為什么要重載，就是為了使用和內置類型一樣的自然，如果像上面我定義的void那樣，那么恐怕就很難懂了，如果將減號定義為加法的話，那么就更加的匪夷所思。也很難讀了，違背了初衷，也就是一種錯誤的做法了，雖然理論上是可行的。。

計算機是一個很奇妙的東西，需要我們用心去體會……
                                                                                                                  ------------------------------<本章完>