【C++ 函数基础】定义、声明、调用、返回值与参数传递
引言
在编写程序时,我们经常需要重复执行某段代码。如果每次都重写一遍,不仅代码冗余,而且难以维护。函数 是 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++ 程序,完成以下任务:
- 定义一个函数
int maxOfThree(int a, int b, int c),返回三个整数中的最大值。- 定义一个函数
void swapByPointer(int* x, int* y),通过指针交换两个整数的值。- 定义一个函数
void swapByReference(int& x, int& y),通过引用交换两个整数的值。- 在
main函数中,从键盘读取三个整数,调用maxOfThree输出最大值。- 定义两个整数变量
p = 10, q = 20,分别调用swapByPointer和swapByReference交换它们,输出交换后的值,验证两种方式的效果。- 写一个函数
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++ 程序的基本构建块。通过定义、声明和调用,我们可以实现代码复用。参数传递方式(值传递、指针传递、引用传递)决定了函数能否修改外部数据以及效率。理解函数调用栈的内存模型,有助于你调试递归和复杂函数调用。通过今天的练习题,你应该能熟练编写和调用各种函数。
AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念,把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起,为开发者提供从开发、训练到部署的一站式体验。
更多推荐
所有评论(0)