引言

在编写程序时,我们经常需要重复执行某段代码。如果每次都重写一遍,不仅代码冗余,而且难以维护。函数 是 C++ 中实现代码复用和模块化的核心机制:它将一段具有独立功能的代码封装起来,并赋予一个名字,通过名字就可以随时调用。使用函数可以让程序结构清晰、易于调试和扩展。


1. 函数定义与声明

1.1 函数定义

函数定义包括返回类型、函数名、参数列表和函数体。

// 返回类型 函数名(参数列表) {
//     函数体
//     return 返回值;
// }

int add(int a, int b) {
    return a + b;
}
  • 返回类型:函数执行完毕后返回的数据类型,若无需返回则写 void。
  • 参数列表:调用函数时需要传递给函数的数据,可以为空。
  • 函数体:实现具体功能的代码块。

1.2 函数声明(原型)

函数声明告诉编译器函数的存在,包括返回类型、函数名和参数类型(参数名可省略)。通常放在文件开头或头文件中。

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

int main() {
    int result = add(3, 5);  // 调用
    return 0;
}

// 函数定义可以放在后面
int add(int a, int b) {
    return a + b;
}

为什么需要声明:编译器从上到下编译代码,如果函数调用出现在定义之前,没有声明会导致编译错误。


2. 函数调用

通过函数名和实参列表来调用函数,执行函数体,然后返回到调用点。

#include <iostream>

void sayHello() {
    std::cout << "Hello!" << std::endl;
}

int main() {
    sayHello();   // 调用无参函数
    int x = 10, y = 20;
    int s = add(x, y);  // 调用有参函数,实参传递给形参
    std::cout << "Sum: " << s << std::endl;
    return 0;
}

调用时,实参的值会复制给形参(值传递情况下)。函数可以嵌套调用(一个函数调用另一个函数)。


3. 返回值

使用 return 语句从函数中返回一个值,并立即结束函数执行。返回类型必须与函数声明一致(除非有隐式转换)。

int max(int a, int b) {
    if (a > b)
        return a;
    else
        return b;
    // 执行不到这里的代码
}

void printMessage(const std::string& msg) {
    std::cout << msg << std::endl;
    return;  // void 函数中的 return 可省略
}
  • 非 void 函数的所有分支必须都有 return,否则产生未定义行为。
  • 返回局部变量的地址或引用是危险的(悬垂指针/引用)。

4. 参数传递

4.1 值传递(pass by value)

形参是实参的副本,函数内修改形参不影响实参。

void changeValue(int x) {
    x = 100;   // 只修改副本
}

int main() {
    int a = 10;
    changeValue(a);
    std::cout << a;  // 输出 10,a 未改变
    return 0;
}

4.2 指针传递(pass by pointer)

形参是指针,可以通过指针修改实参的值(需要传递地址)。

void changeByPointer(int* ptr) {
    *ptr = 200;   // 修改指针指向的对象
}

int main() {
    int a = 10;
    changeByPointer(&a);
    std::cout << a;  // 输出 200
    return 0;
}

4.3 引用传递(pass by reference)

形参是实参的别名,直接操作实参,语法简洁。

void changeByReference(int& ref) {
    ref = 300;
}

int main() {
    int a = 10;
    changeByReference(a);
    std::cout << a;  // 输出 300
    return 0;
}

对比总结:

  • 值传递:安全,但拷贝大对象开销大。
  • 指针传递:可以修改实参,需要检查空指针,语法稍繁琐。
  • 引用传递:可以修改实参,不能为空,语法简洁,是 C++ 推荐的方式。

4.4 传递数组(退化指针)

数组作为参数时,会退化为指向首元素的指针,需要额外传递长度。

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

5. 内存模型讲解:函数调用栈

当程序调用一个函数时,系统在内存的栈区为这个函数分配一块空间,称为栈帧。栈帧中保存了:

  • 函数的返回地址(调用结束后回到哪里)
  • 函数参数(值传递的副本)
  • 局部变量
  • 一些寄存器状态

5.1 值传递的内存过程

int add(int a, int b) {
    int c = a + b;
    return c;
}

int main() {
    int x = 3, y = 4;
    int z = add(x, y);
    return 0;
}

内存栈示意图(地址从高到低增长):

调用 add 前 main 的栈帧:
高地址 +---------+
        | ...     |
        | x=3     |
        | y=4     |
低地址 +---------+

调用 add 时,创建新的栈帧:
高地址 +---------+
        | 返回地址 | (指向 main 中调用点之后)
        | 参数 a=3 | (拷贝 x)
        | 参数 b=4 | (拷贝 y)
        | 局部 c=7 |
低地址 +---------+

add 执行完毕,返回值通常放在寄存器(如 eax)中,然后销毁 add 的栈帧,恢复 main 的栈帧,将返回值赋给 z。
  • 参数和局部变量都在栈上分配。
  • 值传递时,实参被复制到形参的内存中,因此修改形参不影响实参。

5.2 引用传递的内存过程

引用本质上是一个隐式指针,但语法上像别名。引用传递时,栈帧中存放的是实参的地址(而不是副本)。

void change(int& ref) {
    ref = 100;
}
int main() {
    int a = 10;
    change(a);
}

在 change 的栈帧中,ref 占用指针大小(4/8字节),存储 a 的地址。对 ref 的赋值会间接修改 a 的内存。

5.3 返回值的处理

小尺寸的返回值(如 int)通常通过寄存器返回。大尺寸的返回值(如结构体)编译器可能会在调用者栈中预留空间,并将地址隐式传递给被调用函数。


6. 常见错误与避坑

错误说明正确做法
函数声明与定义不匹配返回类型、参数类型或数量不一致保持声明与定义完全一致
忘记在非 void 函数中 return未定义行为,可能返回随机值确保所有分支都有 return
返回局部变量的地址或引用函数结束后局部变量被销毁,指针悬垂返回静态变量、动态分配或值
值传递传递大对象导致性能低下每次调用都复制整个对象使用 const & 传递
指针传递未检查空指针解引用 nullptr 导致崩溃断言或条件检查

7. 练习题

题目:编写一个 C++ 程序,完成以下任务:

  1. 定义一个函数 int maxOfThree(int a, int b, int c),返回三个整数中的最大值。
  2. 定义一个函数 void swapByPointer(int* x, int* y),通过指针交换两个整数的值。
  3. 定义一个函数 void swapByReference(int& x, int& y),通过引用交换两个整数的值。
  4. 在 main 函数中,从键盘读取三个整数,调用 maxOfThree 输出最大值。
  5. 定义两个整数变量 p = 10, q = 20,分别调用 swapByPointer 和 swapByReference 交换它们,输出交换后的值,验证两种方式的效果。
  6. 写一个函数 void printArray(const int arr[], int size),使用 const 修饰数组参数,输出所有元素。在 main 中定义一个数组并调用它。

期望输出(示例):

请输入三个整数:5 12 8
最大值:12
交换前: p=10, q=20
指针交换后: p=20, q=10
引用交换后: p=10, q=20
数组元素:1 2 3 4 5

上期参考答案

#include <iostream>
#include <cstring>

// 1. 共用体与类型指示
enum class ValueType { INT, FLOAT, STRING };

union Value {
    int i;
    float f;
    char str[20];
};

struct TaggedValue {
    ValueType type;
    Value data;
};

// 3. 位域结构体(使用 unsigned char 作为底层,需编译器支持)
struct Status {
    unsigned char isReady : 1;
    unsigned char errorCode : 3;
    unsigned char priority : 2;
    unsigned char reserved : 2;  // 填充
};

int main() {
    // 2. 使用共用体 + 标签
    TaggedValue tv;
    
    tv.type = ValueType::INT;
    tv.data.i = 100;
    std::cout << "存储整数: " << tv.data.i << std::endl;
    
    tv.type = ValueType::FLOAT;
    tv.data.f = 3.1415f;
    std::cout << "存储浮点数: " << tv.data.f << std::endl;
    
    tv.type = ValueType::STRING;
    strcpy(tv.data.str, "Hello");
    std::cout << "存储字符串: " << tv.data.str << std::endl;
    
    // 4. 位域测试
    Status s;
    s.isReady = 1;
    s.errorCode = 5;   // 二进制 101
    s.priority = 2;    // 二进制 10
    s.reserved = 0;
    
    std::cout << "Status 大小: " << sizeof(Status) << " 字节" << std::endl;
    
    // 输出底层字节(假设小端序,且位域从低位开始分配)
    unsigned char* bytePtr = reinterpret_cast<unsigned char*>(&s);
    std::cout << "Status 原始字节: 0x" << std::hex << (int)*bytePtr << std::dec << std::endl;
    // 解释:假设布局(从低位开始): bit0=isReady, bit1-3=errorCode, bit4-5=priority, bit6-7=reserved
    // 那么 isReady=1 -> bit0=1, errorCode=5 -> bits1-3=101, priority=2 -> bits4-5=10
    // 组合二进制: 00 10 101 1 = 0010 1011 = 0x2B (可能输出 0x2b)
    
    // 5. 解释
    std::cout << "共用体不能同时存储多个成员,因为所有成员共享内存。" << std::endl;
    std::cout << "C++17 中更安全的替代方案: std::variant (类型安全的联合)" << std::endl;
    
    return 0;
}

总结:函数是 C++ 程序的基本构建块。通过定义、声明和调用,我们可以实现代码复用。参数传递方式(值传递、指针传递、引用传递)决定了函数能否修改外部数据以及效率。理解函数调用栈的内存模型,有助于你调试递归和复杂函数调用。通过今天的练习题,你应该能熟练编写和调用各种函数。

Logo

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念,把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起,为开发者提供从开发、训练到部署的一站式体验。

更多推荐