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

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

函數的定義和調用

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

#include 

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

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

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

函數的參數和返回值

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

#include 

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

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

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

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

函數的重載

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

#include 

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

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

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

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

    return 0;
}

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

參數傳遞

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

值傳遞

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

#include 

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

引用傳遞

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

#include 

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

選擇哪種方式

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

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

函數匹配

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

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

實參類型的精確匹配

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

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

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

實參類型的標準類型轉換

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

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

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

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

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

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

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

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

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

函數模版匹配

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

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

?

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;
}

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