《c++primer》 第6章：函数

6.1 函数基础

#include <iostream>

// 定义一个简单的函数，用于计算两个整数的和
// 参数 a：第一个整数
// 参数 b：第二个整数
// 返回值：两个整数的和
int add(int a, int b) {
    // 计算 a 和 b 的和
    int result = a + b; 
    // 返回计算结果
    return result; 
}

int main() {
    // 调用 add 函数，传入参数 3 和 5
    int sum = add(3, 5); 
    // 输出计算结果
    std::cout << "The sum is: " << sum << std::endl; 
    return 0;
}

6.2 参数传递

#include <iostream>

// 值传递：函数接收的是实参的副本
// 参数 num：传入的整数，函数内部操作的是该整数的副本
void valuePassing(int num) {
    // 修改副本的值
    num = num + 1; 
    // 输出修改后的副本值
    std::cout << "Inside valuePassing: " << num << std::endl; 
}

// 引用传递：函数接收的是实参的引用，直接操作实参
// 参数 ref：传入整数的引用
void referencePassing(int& ref) {
    // 修改引用所指向的实参的值
    ref = ref + 1; 
    // 输出修改后的实参值
    std::cout << "Inside referencePassing: " << ref << std::endl; 
}

int main() {
    int x = 10;
    // 调用值传递函数
    valuePassing(x); 
    // 输出调用值传递函数后 x 的值，x 未改变
    std::cout << "After valuePassing: " << x << std::endl; 

    int y = 20;
    // 调用引用传递函数
    referencePassing(y); 
    // 输出调用引用传递函数后 y 的值，y 已改变
    std::cout << "After referencePassing: " << y << std::endl; 

    return 0;
}

6.3 返回类型和 return 语句

#include <iostream>

// 返回一个整数
// 参数 a：第一个整数
// 参数 b：第二个整数
// 返回值：两个整数中的较大值
int max(int a, int b) {
    // 判断 a 是否大于等于 b
    if (a >= b) {
        // 如果是，返回 a
        return a; 
    } else {
        // 否则返回 b
        return b; 
    }
}

// 返回引用
// 参数 arr：整数数组
// 参数 index：数组的索引
// 返回值：数组中指定索引位置元素的引用
int& getElement(int arr[], int index) {
    // 返回数组中指定索引位置元素的引用
    return arr[index]; 
}

int main() {
    int m = 3, n = 5;
    // 调用 max 函数获取较大值
    int maxVal = max(m, n); 
    // 输出较大值
    std::cout << "The maximum value is: " << maxVal << std::endl; 

    int myArray[5] = {1, 2, 3, 4, 5};
    // 调用 getElement 函数获取数组中索引为 2 的元素的引用
    int& elementRef = getElement(myArray, 2); 
    // 修改引用所指向的元素的值
    elementRef = 10; 
    // 输出修改后的元素值
    std::cout << "Modified element: " << myArray[2] << std::endl; 

    return 0;
}

6.4 函数重载

#include <iostream>

// 重载函数 1：计算两个整数的和
// 参数 a：第一个整数
// 参数 b：第二个整数
// 返回值：两个整数的和
int add(int a, int b) {
    // 计算两个整数的和
    return a + b; 
}

// 重载函数 2：计算两个双精度浮点数的和
// 参数 x：第一个双精度浮点数
// 参数 y：第二个双精度浮点数
// 返回值：两个双精度浮点数的和
double add(double x, double y) {
    // 计算两个双精度浮点数的和
    return x + y; 
}

int main() {
    // 调用整数版本的 add 函数
    int intSum = add(3, 5); 
    // 输出整数和
    std::cout << "Integer sum: " << intSum << std::endl; 

    // 调用双精度浮点数版本的 add 函数
    double doubleSum = add(3.2, 5.7); 
    // 输出双精度浮点数和
    std::cout << "Double sum: " << doubleSum << std::endl; 

    return 0;
}

6.5 特殊用途语言特性

#include <iostream>

// 默认参数：为函数参数提供默认值
// 参数 a：第一个整数，默认值为 0
// 参数 b：第二个整数，默认值为 1
int defaultParams(int a = 0, int b = 1) {
    // 计算两个整数的和
    return a + b; 
}

// 内联函数：建议编译器将函数体直接嵌入调用处
// 参数 c：整数
// 返回值：c 的两倍
inline int inlineFunction(int c) {
    // 返回 c 的两倍
    return 2 * c; 
}

int main() {
    // 调用默认参数函数，使用默认值
    int result1 = defaultParams(); 
    // 输出结果
    std::cout << "Result with default params: " << result1 << std::endl; 

    // 调用默认参数函数，传入参数
    int result2 = defaultParams(3, 5); 
    // 输出结果
    std::cout << "Result with provided params: " << result2 << std::endl; 

    // 调用内联函数
    int result3 = inlineFunction(4); 
    // 输出结果
    std::cout << "Result of inline function: " << result3 << std::endl; 

    return 0;
}

6.6 函数匹配

#include <iostream>

// 函数 1：接收一个整数参数
// 参数 num：整数
void func(int num) {
    // 输出提示信息
    std::cout << "func(int): " << num << std::endl; 
}

// 函数 2：接收一个双精度浮点数参数
// 参数 val：双精度浮点数
void func(double val) {
    // 输出提示信息
    std::cout << "func(double): " << val << std::endl; 
}

int main() {
    int x = 10;
    // 调用函数，根据参数类型匹配 func(int)
    func(x); 

    double y = 3.14;
    // 调用函数，根据参数类型匹配 func(double)
    func(y); 

    return 0;
}

6.7 函数指针

#include <iostream>

// 定义一个函数，用于计算两个整数的和
// 参数 a：第一个整数
// 参数 b：第二个整数
// 返回值：两个整数的和
int add(int a, int b) {
    // 计算两个整数的和
    return a + b; 
}

// 定义一个函数，用于计算两个整数的差
// 参数 a：第一个整数
// 参数 b：第二个整数
// 返回值：两个整数的差
int subtract(int a, int b) {
    // 计算两个整数的差
    return a - b; 
}

int main() {
    // 定义一个函数指针，指向返回值为 int，参数为两个 int 的函数
    int (*funcPtr)(int, int); 

    // 让函数指针指向 add 函数
    funcPtr = add; 
    // 通过函数指针调用 add 函数
    int sum = funcPtr(3, 5); 
    // 输出计算结果
    std::cout << "Sum: " << sum << std::endl; 

    // 让函数指针指向 subtract 函数
    funcPtr = subtract; 
    // 通过函数指针调用 subtract 函数
    int diff = funcPtr(8, 3); 
    // 输出计算结果
    std::cout << "Difference: " << diff << std::endl; 

    return 0;
}

这些代码示例涵盖了《C++ Primer》第 6 章中函数相关的各个知识点，每个函数的参数和代码行都有详细的注释，方便理解。