函數(shù)是 C++ 中的一個重要概念，它可以讓我們將一段代碼封裝起來，然后在需要的時候調用它。C++ 中的函數(shù)有以下幾個特點：

• 函數(shù)可以有參數(shù)和返回值。
• 函數(shù)可以被其他函數(shù)調用。
• 函數(shù)可以被重載，即可以定義多個同名的函數(shù)，只要它們的參數(shù)列表不同即可。

函數(shù)的定義和調用

在 C++ 中，函數(shù)的定義和調用都非常簡單。以下是一個簡單的函數(shù)的定義和調用的示例：

#include 

// 定義一個名為 add 的函數(shù)，它有兩個參數(shù) x 和 y，返回值為 x + y
int add(int x, int y) {
    return x + y;
}

int main() {
    // 調用 add 函數(shù)，并將返回值賦值給變量 z
    int z = add(1, 2);
    std::cout << "1 + 2 = " << z << std::endl;
    return 0;
}

在這個示例中，我們定義了一個名為 add 的函數(shù)，它有兩個參數(shù) x 和 y，返回值為 x + y。然后在 main 函數(shù)中，我們調用了 add 函數(shù)，并將返回值賦值給變量 z，最后輸出了 1 + 2 = 3。

函數(shù)的參數(shù)和返回值

在 C++ 中，函數(shù)可以有參數(shù)和返回值。以下是一個帶有參數(shù)和返回值的函數(shù)的示例：

#include 

// 定義一個名為 add 的函數(shù)，它有兩個參數(shù) x 和 y，返回值為 x + y
int add(int x, int y) {
    return x + y;
}

int main() {
    // 調用 add 函數(shù)，并將返回值賦值給變量 z
    int z = add(1, 2);
    std::cout << "1 + 2 = " << z <<
    std::endl;

// 調用 add 函數(shù)，并將返回值賦值給變量 z
}

在這個示例中，我們定義了一個名為 add 的函數(shù)，它有兩個參數(shù) x 和 y，返回值為 x + y。然后在 main 函數(shù)中，我們調用了 add 函數(shù)兩次，并將返回值分別賦值給變量 z，最后輸出了 1 + 2 = 3 和 3 + 4 = 7。

函數(shù)的重載

在 C++ 中，函數(shù)可以被重載，即可以定義多個同名的函數(shù)，只要它們的參數(shù)列表不同即可。以下是一個函數(shù)重載的示例：

#include 

// 定義一個名為 add 的函數(shù)，它有兩個參數(shù) x 和 y，返回值為 x + y
int add(int x, int y) {
    return x + y;
}

// 定義一個名為 add 的函數(shù)，它有三個參數(shù) x、y 和 z，返回值為 x + y + z
int add(int x, int y, int z) {
    return x + y + z;
}

int main() {
    // 調用 add 函數(shù)，并將返回值賦值給變量 z
    int z = add(1, 2);
    std::cout << "1 + 2 = " << z << std::endl;

    // 調用 add 函數(shù)，并將返回值賦值給變量 z
    z = add(1, 2, 3);
    std::cout << "1 + 2 + 3 = " << z << std::endl;

    return 0;
}

在這個示例中，我們定義了兩個同名的函數(shù) add，它們的參數(shù)列表不同。這就是函數(shù)重載的一個例子。函數(shù)重載可以讓我們定義多個同名的函數(shù)，只要它們的參數(shù)列表不同即可。這樣可以讓我們更方便地使用函數(shù)，而不需要為每個函數(shù)取不同的名字。

參數(shù)傳遞

在 C++ 中，函數(shù)的參數(shù)傳遞有兩種方式：值傳遞和引用傳遞。

值傳遞

值傳遞是指將參數(shù)的值復制一份，然后將這份復制傳遞給函數(shù)。在函數(shù)內部，對參數(shù)的修改不會影響到原始的參數(shù)。以下是一個值傳遞的示例：

#include 

// 定義一個名為 add 的函數(shù)，它有兩個參數(shù) x 和 y，返回值為 x + y
int add(int x, int y) {
    x = x + 1;
    y = y + 1;
    return x + y;
}

int main() {
    int a = 1;
    int b = 2;
    int c = add(a, b);
    std::cout << "a = " << a << std::endl; // 輸出 a = 1
    std::cout << "b = " << b << std::endl; // 輸出 b = 2
    std::cout << "c = " << c << std::endl; // 輸出 c = 5
    return 0;
}

在這個示例中，我們定義了一個名為 add 的函數(shù)，它有兩個參數(shù) x 和 y，返回值為 x + y。然后在 main 函數(shù)中，我們定義了三個變量 a、b 和 c，并將 a 和 b 的值分別賦為 1 和 2。然后我們調用了 add 函數(shù)，并將 a 和 b 作為參數(shù)傳遞給它。在 add 函數(shù)內部，我們對 x 和 y 的值進行了修改，但是這些修改不會影響到 a 和 b 的值。

引用傳遞

引用傳遞是指將參數(shù)的引用傳遞給函數(shù)。在函數(shù)內部，對參數(shù)的修改會影響到原始的參數(shù)。以下是一個引用傳遞的示例：

#include 

// 定義一個名為 add 的函數(shù)，它有兩個參數(shù) x 和 y，返回值為 x + y
int add(int& x, int& y) {
    x = x + 1;
    y = y + 1;
    return x + y;
}

int main() {
    int a = 1;
    int b = 2;
    int c = add(a, b);
    std::cout << "a = " << a << std::endl; // 輸出 a = 2
    std::cout << "b = " << b << std::endl; // 輸出 b = 3
    std::cout << "c = " << c << std::endl; // 輸出 c = 6
    return 0;
}

在這個示例中，我們定義了一個名為 add 的函數(shù)，它有兩個參數(shù) x 和 y，返回值為 x + y。然后在 main 函數(shù)中，我們定義了三個變量 a、b 和 c，并將 a 和 b 的值分別賦為 1 和 2。然后我們調用了 add 函數(shù)，并將 a 和 b 的引用作為參數(shù)傳遞給它。在 add 函數(shù)內部，我們對 x 和 y 的值進行了修改，這些修改會影響到 a 和 b 的值。

選擇哪種方式

在選擇參數(shù)傳遞方式時，需要考慮以下幾個因素：

• 如果參數(shù)是一個較小的基本類型（如 int、double 等），可以使用值傳遞。
• 如果參數(shù)是一個較大的結構體或類，可以使用引用傳遞，這樣可以避免復制大量的數(shù)據(jù)。
• 如果需要在函數(shù)內部修改參數(shù)的值，并且希望這些修改能夠影響到原始的參數(shù)，可以使用引用傳遞。

函數(shù)匹配

在C++中，函數(shù)匹配是指編譯器在調用函數(shù)時，根據(jù)實參的類型和數(shù)量，從函數(shù)的重載集合中選擇一個最佳的匹配函數(shù)的過程。函數(shù)匹配是C++中的一個重要概念，它決定了程序調用哪個函數(shù)，因此對于C++程序員來說，了解函數(shù)匹配的規(guī)則和原理是非常重要的。C++中的函數(shù)匹配規(guī)則比較復雜，主要包括以下幾個方面：

• 實參類型的精確匹配
• 實參類型的標準類型轉換
• 實參類型的用戶自定義類型轉換
• 函數(shù)模板的匹配

實參類型的精確匹配

如果函數(shù)的形參類型和實參類型完全一致，那么這個函數(shù)就是一個精確匹配。例如，下面的代碼中，foo函數(shù)的形參類型和實參類型完全一致，因此它是一個精確匹配：

void foo(int x, double y) {
    // ...
}

int main() {
    int a = 1;
    double b = 2.0;
    foo(a, b); // 精確匹配
    return 0;
}

實參類型的標準類型轉換

如果函數(shù)的形參類型和實參類型不一致，但是可以通過標準類型轉換（如整型提升、算術類型轉換、指針類型轉換等）將實參類型轉換為形參類型，那么這個函數(shù)就是一個標準類型轉換匹配。 實例如，下面的代碼中，foo函數(shù)的形參類型是int, 而實參類型是short，但是可以通過整型提升將short類型轉換為int類型，因此foo函數(shù)是一個標準類型轉換匹配：

void foo(int x, double y) {
    // ...
}

int main() {
    short a = 1;
    double b = 2.0;
    foo(a, b); // 標準類型轉換匹配
    return 0;
}

實參類型的用戶自定義類型轉換

如果函數(shù)的形參類型和實參類型不一致，且不能通過標準類型轉換將實參類型轉換為形參類型，但是可以通過用戶自定義類型轉換將實參類型轉換為形參類型，那么這個函數(shù)就是一個用戶自定義類型轉換匹配。例如，下面的代碼中，foo函數(shù)的形參類型是double，而實參類型是int，但是可以通過用戶自定義類型轉換將int類型轉換為double類型，因此foo函數(shù)是一個用戶自定義類型轉換匹配：

class A {
public:
    operator double() const {
        return 0.0;
    }
};

void foo(double x) {
    // ...
}

int main() {
    A a;
    foo(a); // 用戶自定義類型轉換匹配
    return 0;
}

在上面的例子中，foo函數(shù)的形參類型是double，而實參類型是A，但是可以通過用戶自定義類型轉換將A類型轉換為double類型。具體來說，A類定義了一個類型轉換函數(shù)operator double()，該函數(shù)將A類型轉換為double類型。當我們調用foo函數(shù)時，編譯器會自動調用A類的類型轉換函數(shù)，將A類型轉換為double類型，然后將轉換后的double類型作為實參傳遞給foo函數(shù)。

函數(shù)模版匹配

在C++中，函數(shù)模板匹配是通過模板參數(shù)推導來實現(xiàn)的。當我們調用一個函數(shù)模板時，編譯器會根據(jù)實參的類型推導出模板參數(shù)的類型，然后根據(jù)模板參數(shù)的類型來匹配函數(shù)模板。具體來說，編譯器會根據(jù)實參的類型推導出模板參數(shù)的類型，然后將模板參數(shù)的類型與函數(shù)模板的形參類型進行匹配。如果匹配成功，則使用該函數(shù)模板來生成對應的函數(shù)實例；否則，編譯器會報錯。

?需要注意的是，函數(shù)模板匹配是一種非常靈活的機制，它可以根據(jù)實參的類型來推導出模板參數(shù)的類型，從而實現(xiàn)類型自動推導。但是，由于函數(shù)模板匹配是在編譯時進行的，因此需要滿足一定的語法規(guī)則和限制。例如，函數(shù)模板的形參類型不能是引用類型，否則會導致模板參數(shù)推導失?。缓瘮?shù)模板的形參類型不能是void類型，否則會導致編譯錯誤等。 下面是一個函數(shù)模板匹配的例子：

?

template <typename T>
void foo(T x) {
    std::cout << x << std::endl;
}

int main() {
    foo(1); // T = int
    foo(1.0); // T = double
    foo("hello"); // T = const char*
    return 0;
}

在上面的代碼中，我們定義了一個函數(shù)模板foo，它有一個模板參數(shù)T和一個形參x。當我們調用foo函數(shù)時，編譯器會根據(jù)實參的類型推導出模板參數(shù)的類型，然后將模板參數(shù)的類型與函數(shù)模板的形參類型進行匹配。例如，當我們調用foo(1)時，編譯器會推導出T為int，從而使用foo來生成對應的函數(shù)實例。當我們調用foo(1.0)時，編譯器會推導出T為double，從而使用foo來生成對應的函數(shù)實例。當我們調用foo("hello")時，編譯器會推導出T為const char，從而使用foo來生成對應的函數(shù)實例。