C++學習筆記（二）

C++重載（overloading）和其它編程語言中的重載概念基本上是一致的。C++重載包括操作符重載與函數重載，下面通過例子來說明。

操作符重載

操作符重載使用關鍵字operator。

操作符重載能夠使同一個操作符具有不同的操作含義，滿足更廣泛範圍的操作需要。例如，對於一個容器類my_list，你可以重載操作符+=號，重載的含義是對兩個MyList使用+=執行相加，表示將兩個my_list的內容合併到一起，下面實現my_list的操作符重載，代碼如下所示：

#include <iostream>
#include <list>

using namespace std;

class my_list;
void test_my_list();

int main() {
    test_my_list();
    return 0;
}

class my_list {
    public:
        my_list(list<int> &a_list):int_list(a_list) {
        }
        inline my_list& operator+=(const my_list& some_my_list) {
            if(some_my_list.int_list.size()) {
                int_list.merge(some_my_list.int_list);
            }
            return *this;
        }
        void print_list() {
            cout<<"size("<<int_list.size()<<"):";
            list<int>::iterator iter;
            for(iter=int_list.begin(); iter!=int_list.end(); iter++) {
                cout<<*iter<<"  ";
            }
            cout<<endl;
        }
    private:
        list<int> &int_list;
};

void test_my_list() {
    list<int> ll;
    ll.push_back(1);
    ll.push_back(2);
    ll.push_back(3);
    my_list a(ll);
    a.print_list();

    list<int> new_list;
    new_list.push_back(11);
    new_list.push_back(12);
    my_list b(new_list);
    b.print_list();

    a += b;
    a.print_list();
}

上述代碼中，a和b都是my_list類型，執行a+=b的結果是將b中包含的list的集合累加到a的的list集合中。

編譯運行，輸出運行結果：

[hadoop@localhost c++]$ g++ -Wall -o mynote02 mynote02.cpp 
[hadoop@localhost c++]$ ./mynote02 
size(3):1  2  3  
size(2):11  12  
size(5):1  2  3  11  12  

可見，實現了操作符重載，實現兩個my_list集合的合併。

函數重載

函數重載都是爲了能夠共享同一個函數名稱，而具有相同的函數名稱的函數具有不同類型的參數，這些具有相同函數名稱的函數就是通過重載而定義的。一定要明確，重載的函數或者具有不同類型的形參，或者具有不同個數的形參。例如，如果同時定義函數int getMax(int &x, int &y)與int getMax(int x, int y)，這兩個函數是不能夠重載的，編譯器無法辨認到底調用的是哪一個函數。
舉個簡單的例子：

#include <iostream>
#include <string>
#include <list>
#include <deque>

using namespace std;

string& get_max(list<string>& container);
string& get_max(deque<string>& container);
string& get_max(string& a, string& b);

string max_string("");

int main() {
    list<string> container;
    container.push_back("hello, a good day.");
    container.push_back("bad boy.");
    container.push_back("how flies!");
    cout<<get_max(container)<<endl;

    deque<string> deck;
    deck.push_front("actions speak louder than words.");
    deck.push_back("yeah!");
    deck.push_front("summer rain.");
    cout<<get_max(deck)<<endl;

    string a("last night");
    string b("so bad.");
    cout<<get_max(a, b)<<endl;

    return 0;
}

string& get_max(list<string>& container) {
    list<string>::iterator iter;
    for(iter=container.begin(); iter!=container.end(); iter++) {
        if((iter->size()>max_string.size()) {
            max_string = *iter;
        }
    }
    return max_string;
}

string& get_max(deque<string>& deck) {
    for(int i=0; i<deck.size(); i++) {
        if(deck[i].size()>max_string.size()) {
            max_string = deck[i];
        }
    }
    return max_string;
}

string& get_max(string& a, string& b) {
    max_string = a.size()>=b.size() ? a : b;
    return max_string;
}

上面聲明並定義了三個同名的函數，都是求最長的字符串，這三個函數是重載的例子：

函數string& get_max(list<string>& container);與函數string& get_max(deque<string>& container);重載，函數名稱相同，參數個數相同，但是參數類型不同；

函數string& get_max(list<string>& container);與string& get_max(string& a, string& b);重載，函數名稱相同，但是參數個數不同；

函數string& get_max(deque<string>& container);與string& get_max(string& a, string& b);重載，函數名稱相同，但是參數個數不同；

編譯運行，輸出結果如下所示： 

[shirdrn@localhost 02]$ g++ -Wall -o mynote02 mynote02.cpp 
[shirdrn@localhost 02]$ ./mynote02 
hello, a good day.
actions speak louder than words.
last night

可見，對於上面三個函數，編譯器能夠分辨出實際調用的是哪一個函數，因此是合法的函數聲明和定義。