《C++ Primer》导学系列：第 6 章 - 函数

6.1 函数基础

6.1.1 基本概念

函数是C++程序的基本组成单元，用于将代码组织成可以复用的模块。函数通过函数名进行调用，并且可以接受参数和返回值。函数的定义包括函数头和函数体，其中函数头描述了函数的接口，函数体包含了具体的实现代码。

函数的定义

函数的定义通常包括返回类型、函数名、参数列表和函数体。函数头声明了函数的返回类型和参数类型，函数体则包含实际执行的代码。

示例代码

#include <iostream>

// 函数定义
int add(int a, int b) {
    return a + b;  // 返回 a 和 b 的和
}

int main() {
    int result = add(3, 4);  // 调用 add 函数
    std::cout << "Result: " << result << std::endl;  // 输出结果
    return 0;
}

在这个示例中，add函数接受两个整数参数，并返回它们的和。main函数调用add函数并输出结果。

6.1.2 函数声明

在使用函数之前，必须声明函数。函数声明告诉编译器函数的名称、返回类型和参数类型，但不需要具体实现。函数声明通常放在头文件中，函数定义放在源文件中。

示例代码

#include <iostream>

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

int main() {
    int result = add(3, 4);  // 调用 add 函数
    std::cout << "Result: " << result << std::endl;  // 输出结果
    return 0;
}

// 函数定义
int add(int a, int b) {
    return a + b;  // 返回 a 和 b 的和
}

在这个示例中，add函数的声明在main函数之前，定义在main函数之后。

6.1.3 形参和实参

函数在定义时使用形参（形式参数）来指定参数类型和名称，在调用时使用实参（实际参数）来传递具体的值。形参在函数定义时声明，实参在函数调用时提供。

示例代码

#include <iostream>

// 函数定义
void printSum(int a, int b) {
    std::cout << "Sum: " << a + b << std::endl;  // 输出 a 和 b 的和
}

int main() {
    int x = 5;
    int y = 7;
    printSum(x, y);  // 调用 printSum 函数，x 和 y 是实参
    return 0;
}

在这个示例中，printSum函数接受两个整数形参a和b，在调用时传递具体的实参x和y。

6.1.4 返回类型

函数可以返回一个值，返回类型可以是任何基本类型、指针、引用、类类型等。如果函数不返回值，则返回类型为void。

示例代码

#include <iostream>

// 函数定义，返回类型为 int
int multiply(int a, int b) {
    return a * b;  // 返回 a 和 b 的乘积
}

// 函数定义，返回类型为 void
void printMessage() {
    std::cout << "Hello, World!" << std::endl;
}

int main() {
    int result = multiply(3, 4);  // 调用 multiply 函数
    std::cout << "Result: " << result << std::endl;  // 输出结果

    printMessage();  // 调用 printMessage 函数
    return 0;
}

在这个示例中，multiply函数返回两个整数的乘积，而printMessage函数不返回值。

6.1.5 函数调用

函数调用是通过函数名和参数列表来实现的。函数调用时，实参的值被传递给形参，并执行函数体中的代码。

示例代码

#include <iostream>

// 函数定义
int subtract(int a, int b) {
    return a - b;  // 返回 a 和 b 的差
}

int main() {
    int a = 10;
    int b = 3;
    int result = subtract(a, b);  // 调用 subtract 函数
    std::cout << "Result: " << result << std::endl;  // 输出结果
    return 0;
}

在这个示例中，subtract函数接受两个整数参数并返回它们的差，在main函数中调用并输出结果。

重点与难点分析

重点：

1. 函数定义与声明：掌握函数的定义和声明方法，理解函数头和函数体的组成。
2. 形参和实参：理解形参和实参的概念及其在函数定义和调用中的作用。
3. 返回类型：掌握函数返回类型的定义方法，理解void类型的应用场景。

难点：

1. 函数调用：初学者需要通过实践掌握函数调用的语法，理解实参与形参的对应关系。
2. 返回类型的应用：在复杂的程序中，合理设计和使用函数的返回类型，特别是指针和引用类型的返回值。

练习题解析

练习6.1：编写一个函数，接受一个整数参数并打印该整数的平方。

• • 示例代码：

#include <iostream>

void printSquare(int x) {
    std::cout << "Square: " << x * x << std::endl;
}

int main() {
    printSquare(4);
    return 0;
}

练习6.2：编写一个函数，接受一个字符参数并返回该字符的大写形式。

• • 示例代码：

#include <iostream>
#include <cctype>

char toUpperCase(char c) {
    return std::toupper(c);
}

int main() {
    char c = 'a';
    char result = toUpperCase(c);
    std::cout << "Uppercase: " << result << std::endl;
    return 0;
}

练习6.3：编写一个void函数，不接受任何参数，并打印一条问候消息。

• • 示例代码：

#include <iostream>

void greet() {
    std::cout << "Hello, welcome to C++ programming!" << std::endl;
}

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

总结与提高

本节总结：

1. 学习了函数的基本概念，掌握了函数的定义、声明和调用方法。
2. 理解了形参和实参的作用，掌握了返回类型的定义和应用。
3. 通过示例代码和练习题，加深了对函数基础知识的理解和应用。

提高建议：

1. 多练习函数的定义和调用：通过编写各种包含函数的程序，熟悉函数的定义、声明和调用方法。
2. 深入理解形参和实参：通过实践掌握形参和实参的对应关系，确保函数调用时参数传递正确。
3. 合理设计函数的返回类型：在编写复杂程序时，合理设计和使用函数的返回类型，提高代码的可读性和维护性。

6.2 参数传递

6.2.1 传值参数

按值传递是将实参的值复制一份传递给函数的形参。函数对形参的修改不会影响实参的值。按值传递适用于传递基本数据类型（如int, double等）和小型的结构体或类对象。

示例代码

#include <iostream>

void increment(int x) {
    ++x;  // 仅修改形参 x 的值
    std::cout << "Inside function: " << x << std::endl;
}

int main() {
    int a = 5;
    increment(a);  // 按值传递，实参 a 的值不会改变
    std::cout << "Outside function: " << a << std::endl;
    return 0;
}

在这个示例中，increment函数按值传递参数x，修改形参不会影响实参a。

6.2.2 传引用参数

按引用传递是将实参的引用传递给函数的形参，函数对形参的修改将直接影响实参。按引用传递适用于需要在函数内部修改实参值的情况，或者传递较大的对象以避免不必要的复制开销。

示例代码

#include <iostream>

void increment(int &x) {
    ++x;  // 修改形参 x 的值，会影响实参
    std::cout << "Inside function: " << x << std::endl;
}

int main() {
    int a = 5;
    increment(a);  // 按引用传递，实参 a 的值会改变
    std::cout << "Outside function: " << a << std::endl;
    return 0;
}

在这个示例中，increment函数按引用传递参数x，修改形参会影响实参a。

6.2.3 const形参和实参

为了防止函数修改传递的实参，可以使用常量引用（const reference）。常量引用既避免了按值传递的复制开销，又保证了实参在函数内部不被修改。

示例代码

#include <iostream>

void printValue(const int &x) {
    std::cout << "Value: " << x << std::endl;
    // 不能修改 x 的值
}

int main() {
    int a = 5;
    printValue(a);  // 按常量引用传递，实参 a 的值不会改变
    return 0;
}

在这个示例中，printValue函数按常量引用传递参数x，保证形参不会修改实参a。

6.2.4 数组形参

在C++中，数组作为函数参数时，会退化为指针。这意味着传递的是数组首元素的地址，而不是整个数组的值。

示例代码

#include <iostream>

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[] = {1, 2, 3, 4, 5};
    int size = sizeof(myArray) / sizeof(myArray[0]);
    printArray(myArray, size);  // 按指针传递数组
    return 0;
}

在这个示例中，printArray函数接受一个数组指针和数组大小，并打印数组的元素。

6.2.5 main函数的形参

main函数可以接受两个参数，通常用于命令行参数的传递。参数argc表示参数的个数，参数argv是一个字符指针数组，包含传递的参数。

示例代码

#include <iostream>

int main(int argc, char *argv[]) {
    std::cout << "Number of arguments: " << argc << std::endl;
    for (int i = 0; i < argc; ++i) {
        std::cout << "Argument " << i << ": " << argv[i] << std::endl;
    }
    return 0;
}

在这个示例中，main函数接受命令行参数并打印出来。

6.2.6 含有可变参数的函数

C++提供了可变参数模板（variadic templates）来处理参数数量不确定的情况。通过使用省略号（...）表示可变参数列表。

示例代码

#include <iostream>
#include <cstdarg>

void printValues(const char *fmt, ...) {
    va_list args;
    va_start(args, fmt);
    while (*fmt != '\0') {
        switch (*fmt++) {
            case 'i': // int
                std::cout << va_arg(args, int) << " ";
                break;
            case