开发实战进阶之函数【c++】二

接上篇开发实战进阶之函数【c++】一

在C++中，函数的声明和定义是两个不同的概念，它们分别用于描述函数的接口和实现。理解这两个概念是编写和组织C++代码的基础。

1. 函数声明

函数声明（或称为函数原型）告诉编译器函数的名称、返回类型、参数类型和参数数量，但不包括函数的具体实现（即函数体）。声明可以让编译器知道如何调用这个函数，即使它的定义还没有出现。函数声明通常放在头文件中。

语法：

返回类型 函数名(参数列表);

示例：

int add(int a, int b); // 函数声明

在这个例子中，int add(int a, int b); 是一个函数声明，表明函数add将接收两个int类型的参数，并返回一个int类型的值。

2. 函数定义

函数定义包括了函数的实际代码实现。它不仅包含函数的声明部分，还包括函数体，即具体的执行代码。函数定义通常放在源文件（.cpp文件）中。

语法：

返回类型 函数名(参数列表)

{

         // 函数体

}

示例：

int add(int a, int b)

{

        return a + b; // 函数定义

}

在这个例子中，int add(int a, int b) 是函数定义，它提供了函数add的具体实现，计算并返回两个整数的和。

3. 函数声明和定义的关系

4. 注意事项

• 单独声明，单独定义：这是C++开发中常见的模式，函数的声明和定义分开出现。声明通常放在头文件中，而定义放在源文件中。这种方式有助于代码的模块化和可维护性。

  示例：

  // 在头文件（如math_functions.h）中
  int add(int a, int b);
  
  // 在源文件（如math_functions.cpp）中
  int add(int a, int b) {
      return a + b;
  }
  

• 声明与定义结合：在某些情况下，声明和定义可以结合在一起，通常出现在较小的程序或简单的类中。

  示例：

  int subtract(int a, int b) {
      return a - b;
  }
  

• 默认参数的声明与定义：如果函数有默认参数值，通常应在声明中提供默认值，定义中不再重复。

  示例：

  void greet(std::string name = "Guest");  // 声明中提供默认参数值
  
  void greet(std::string name) {  // 定义中不再重复默认值
      std::cout << "Hello, " << name << std::endl;
  }
  

• 多次声明，单次定义：在C++中，一个函数可以声明多次（在不同的文件中），但只能定义一次。如果一个函数被定义多次，会引发链接错误。

• 内联函数的声明与定义：内联函数的定义通常放在头文件中，这样每个包含头文件的源文件都能获得函数的定义。

  示例：

  inline int multiply(int a, int b) {
      return a * b;
  }
  

  5. 函数的声明和定义在类中的使用

  在类中，成员函数的声明通常在类内部，而定义可以在类外部。

  示例：

  class MyClass {
  public:
      void display();  // 函数声明
  };
  
  void MyClass::display() {  // 函数定义
      std::cout << "Hello, World!" << std::endl;
  }
  

  总结

• 函数声明告诉编译器函数的接口信息，通常放在头文件中，便于共享。
• 函数定义包含函数的具体实现，通常放在源文件中。

函数传参

在C++中，函数的参数传递方式主要有以下几种：按值传递（Pass by Value）、按引用传递（Pass by Reference）和按指针传递（Pass by Pointer）。每种方式都有其独特的应用场景和优缺点。

1. 按值传递（Pass by Value）

机制：在按值传递中，函数接收的是参数的一个副本。在函数内部对参数的修改不会影响到原始数据。

优点：

• 简单、直观。
• 函数内部对参数的修改不会影响到原来的数据。

缺点：

• 对于大型对象（如大数组、大型类对象），传递副本会消耗更多的内存和处理时间，因为会创建一个新的对象副本。

示例：

void increment(int a) {
    a++;  // 只修改副本，原来的a不会改变
}

int main() {
    int x = 10;
    increment(x);
    std::cout << x << std::endl;  // 输出仍然是10
    return 0;
}

2. 按引用传递（Pass by Reference）

机制：按引用传递时，函数接收的是参数的引用，而不是副本。对参数的任何修改都会影响到原始数据。引用是原始变量的别名，函数内部的操作直接作用于原始变量。

优点：

• 没有副本的开销，效率较高。
• 函数可以修改传递给它的参数。

缺点：

• 可能会意外修改数据，导致不可预期的错误。
• 需要注意函数内对参数的保护，避免不必要的修改。

示例：

void increment(int &a) {
    a++;  // 修改的是原始变量
}

int main() {
    int x = 10;
    increment(x);
    std::cout << x << std::endl;  // 输出11
    return 0;
}

3. 按指针传递（Pass by Pointer）

机制：按指针传递类似于按引用传递，但传递的是指针（即地址）。函数接收的是指向数据的指针，可以通过解引用指针来访问和修改原始数据。

优点：

• 函数可以修改原始数据。
• 适合处理动态数组、链表等复杂数据结构。

缺点：

• 需要处理指针的合法性，防止空指针和野指针错误。
• 指针的操作需要更小心，易出现内存泄漏或其他内存管理问题。

示例：

void increment(int *a) {
    (*a)++;  // 通过指针修改原始变量
}

int main() {
    int x = 10;
    increment(&x);
    std::cout << x << std::endl;  // 输出11
    return 0;
}

4. 按引用传递常量（Pass by Const Reference）

机制：按引用传递常量是按引用传递的一种变体，参数被定义为const，这样在函数内部无法修改传递的参数。它结合了按值传递和按引用传递的优点，既避免了副本开销，又保证了数据不被修改。

优点：

• 没有副本的开销，效率高。
• 保证函数内部不会修改传入的参数。
• 适用于传递大型对象且不希望被修改的情况。

缺点：

• 只能在函数内部读取数据，不能修改。

示例：

void printValue(const int &a) {
    std::cout << a << std::endl;  // 只能读取a，不能修改
}

int main() {
    int x = 10;
    printValue(x);  // 输出10
    return 0;
}

5. 按指针传递常量（Pass by Const Pointer）

机制：与按引用传递常量类似，但通过指针传递常量。函数通过指针访问数据，但不能修改指针所指向的数据。

优点：

• 适合传递指针或数组，并保证数据不被修改。
• 可以处理指向数据的指针，并限制函数对数据的修改权限。

缺点：

• 需要确保指针合法性。
• 不能修改指针指向的内容。

示例：

void printValue(const int *a) {
    std::cout << *a << std::endl;  // 只能读取a指向的值，不能修改
}

int main() {
    int x = 10;
    printValue(&x);  // 输出10
    return 0;
}

数组传参

在C++中，数组和多维数组的传参方式有一定的特殊性，尤其是与普通变量或指针相比。以下是传递数组和多维数组的几种常见方式：

1. 传递一维数组

按指针传递

在C++中，数组名本身就是指向数组首元素的指针。因此，当你将数组传递给函数时，实际上是按指针传递的。这意味着在函数内部你可以通过指针操作整个数组，但不能获取数组的大小（除非通过额外参数传递）。

示例：

void printArray(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

int main() {
    int myArray[5] = {1, 2, 3, 4, 5};
    printArray(myArray, 5);  // 数组名myArray作为指针传递
    return 0;
}

使用引用传递数组

C++允许传递数组的引用，这样可以保留数组的大小信息。这样做可以确保函数只能使用特定大小的数组，并且能够避免指针带来的不安全性。

示例：

void printArray(int (&arr)[5]) {
    for (int i = 0; i < 5; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

int main() {
    int myArray[5] = {1, 2, 3, 4, 5};
    printArray(myArray);  // 按引用传递，数组大小是固定的
    return 0;
}

2. 传递多维数组

按指针传递多维数组

多维数组在传递时，通常也是按指针传递。但在传递多维数组时，必须明确数组的次高维度的大小（即除了最左边维度外的其他维度）。这是因为C++需要知道如何计算指针偏移量来访问数组元素。

示例：

void printMatrix(int arr[][3], int rows) {  // 必须指定列数
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << arr[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

int main() {
    int myMatrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
    printMatrix(myMatrix, 2);  // 数组名myMatrix作为指针传递
    return 0;
}

使用引用传递多维数组

引用传递多维数组时，同样需要指定数组的大小信息，这样传递方式与传递一维数组的引用相似，只是需要指定更多的维度大小。

示例：

void printMatrix(int (&arr)[2][3]) {
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << arr[i][j] << " ";
        }
        std::cout << std::endl;
    }
}

int main() {
    int myMatrix[2][3] = {{1, 2, 3}, {4, 5, 6}};
    printMatrix(myMatrix);  // 按引用传递多维数组
    return 0;
}

3. 传递动态数组

对于动态分配的数组（通过new分配），通常使用指针来传递，同时需要传递数组的大小。

示例：

void printArray(int *arr, int size) {
    for (int i = 0; i < size; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

int main() {
    int *myArray = new int[5]{1, 2, 3, 4, 5};
    printArray(myArray, 5);  // 传递动态数组
    delete[] myArray;  // 释放动态分配的内存
    return 0;
}

4. 使用std::array或std::vector

在C++标准库中，std::array和std::vector提供了更安全、更灵活的数组处理方式。std::array适用于固定大小的数组，而std::vector适用于动态大小的数组。

示例（使用std::array）：

#include <array>
#include <iostream>

void printArray(std::array<int, 5> &arr) {
    for (int i : arr) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::array<int, 5> myArray = {1, 2, 3, 4, 5};
    printArray(myArray);  // 传递std::array
    return 0;
}

示例（使用std::vector）：

#include <vector>
#include <iostream>

void printArray(std::vector<int> &arr) {
    for (int i : arr) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
}

int main() {
    std::vector<int> myArray = {1, 2, 3, 4, 5};
    printArray(myArray);  // 传递std::vector
    return 0;
}

• 对于一维数组和多维数组，可以按指针传递（传递数组名）或按引用传递。按引用传递时，数组的大小必须在函数声明中指定。
• 对于动态数组，通常通过指针传递，并且需要同时传递数组的大小。
• C++标准库提供了std::array和std::vector，推荐使用它们来处理数组，因为它们更加安全且易于管理。

未完待续

开发实战进阶之函数【c++】三