函数设计
函数是 C++ 程序的基本构建块。一个设计良好的函数,应该做到:接口清晰(调用者一看声明就知道怎么用)、行为可预测(不产生意外副作用)、性能高效(参数传递零浪费)。本章系统讲解现代 C++ 中函数设计的核心技巧。
1. 函数基础
声明与定义
函数声明(declaration)告诉编译器函数的签名;函数定义(definition)提供函数体:
// 声明(通常放在头文件 .h / .hpp 中)
int add(int a, int b);
// 定义(通常放在源文件 .cpp 中)
int add(int a, int b) {
return a + b;
}
在现代 C++ 中,如果函数很短(几行以内),直接在头文件中定义为 inline 或在类内定义即可:
// 头文件中的 inline 函数
inline int square(int x) {
return x * x;
}
参数与返回值
函数通过参数接收输入,通过返回值输出结果。这是最自然的数据流动方式:
// 接收两个参数,返回计算结果
double circle_area(double radius) {
return 3.14159265 * radius * radius;
}
// 调用
double area = circle_area(5.0); // area = 78.54...
void 函数
不需要返回值的函数声明为 void。它通常执行某种副作用(打印、修改状态等):
void greet(std::string_view name) {
std::println("Hello, {}!", name);
}
greet("Alice"); // 输出: Hello, Alice!
设计原则
优先设计有返回值的纯函数(无副作用、输出仅由输入决定)。纯函数更容易测试、推理和并行化。只在确实需要副作用时使用 void 函数。
2. 参数传递策略
C++ 提供多种参数传递方式。选对了,代码既安全又高效;选错了,轻则性能浪费,重则产生悬垂引用。
按值传递 (Pass by Value)
传入参数的一份拷贝,函数内的修改不影响原变量:
void increment(int x) {
x += 1; // 只修改局部拷贝
}
int n = 10;
increment(n);
// n 仍然是 10
适合廉价拷贝的小类型:int、double、char、bool、指针、小型结构体(<= 16 字节)。
按 const 引用传递 (Pass by const Reference)
不拷贝,直接引用原对象,但加了 const 保证不会修改:
void analyze(const std::vector<int>& data) {
// 可以读取 data,但不能修改
for (int val : data) {
std::println("{}", val);
}
}
std::vector<int> big_data(1'000'000, 42);
analyze(big_data); // 零拷贝,高效!
适合拷贝代价大的类型:std::string、std::vector、std::map 等容器和大型对象。
按引用传递 (Pass by Reference)
不拷贝,也不加 const — 函数可以修改原对象:
void sort_data(std::vector<int>& data) {
std::ranges::sort(data); // 直接修改原容器
}
std::vector<int> nums = {3, 1, 4, 1, 5};
sort_data(nums);
// nums 现在是 {1, 1, 3, 4, 5}
适合函数需要修改调用者的数据的场景。调用者看到 & 就知道"我的数据可能被改"。
std::string_view:只读字符串的最佳选择
对于只需要读取字符串内容的函数,std::string_view 是最好的参数类型:
void display(std::string_view text) {
std::println("Message: {}", text);
}
// 可以接受各种字符串类型 — 零拷贝
display("hello"); // 字面量
display(std::string("world")); // std::string
std::string s = "test";
display(s); // 已有 string
现代参数传递规则总结
| 场景 | 推荐方式 | 示例 |
|---|---|---|
| 廉价类型(int, double, char, bool, 指针) | 按值 | void f(int x) |
| 只读大对象(vector, map, 自定义大类) | const 引用 | void f(const std::vector<int>& v) |
| 只读字符串 | string_view | void f(std::string_view s) |
| 需要修改调用者的数据 | 引用 | void f(std::vector<int>& v) |
| 需要接管所有权(sink parameter) | 按值 + std::move | void f(std::string name) |
// 完整示例:每种传递方式的最佳用法
void process(int count); // 值传递:廉价类型
void display(std::string_view text); // string_view:只读字符串
void modify(std::vector<int>& data); // 引用:需要修改
void analyze(const std::vector<int>& data); // const引用:只读大对象
class Widget {
std::string name_;
public:
// sink parameter:调用者可以传入临时值(移动)或左值(拷贝)
void set_name(std::string name) {
name_ = std::move(name);
}
};
常见错误
不要为了"效率"给 int、double 这些小类型加 const&。引用本质是指针,按值传递这些小类型反而更快(寄存器直接传递,无需解引用)。
3. 返回值与 RVO
很多 C++ 初学者担心"按值返回大对象会不会产生拷贝?"答案是:不会。现代编译器有 RVO(Return Value Optimization) 和 NRVO(Named RVO)。
RVO — 返回临时对象
返回一个临时构造的对象时,编译器直接在调用者的内存中构造,零拷贝:
std::vector<int> make_sequence(int n) {
return std::vector<int>(n, 0); // RVO:直接构造在调用者处
}
auto seq = make_sequence(1000); // 没有拷贝发生!
C++17 起,这种情况的拷贝省略是标准保证的(guaranteed copy elision),不是可选优化。
NRVO — 返回命名局部变量
返回一个有名字的局部变量时,编译器通常也能优化掉拷贝:
std::vector<int> generate_data() {
std::vector<int> result; // 命名的局部变量
result.push_back(1);
result.push_back(2);
result.push_back(3);
return result; // NRVO:通常不会拷贝
}
auto data = generate_data(); // 高效!
NRVO 不是标准保证,但所有主流编译器(GCC、Clang、MSVC)在优化模式下都会执行。即使没有 NRVO,C++11 起返回局部变量也会自动触发移动而非拷贝。
放心返回值类型
现代 C++ 的指导原则:大胆按值返回。不要为了避免"拷贝"而返回指针或输出参数。RVO/NRVO + 移动语义让按值返回既安全又高效。
绝对不要返回局部变量的引用!
// [错误] 致命错误!返回了局部变量的引用
const std::string& make_greeting(std::string_view name) {
std::string result = std::format("Hello, {}!", name);
return result; // [错误] result 在函数返回后被销毁 → 悬垂引用!
}
// [正确] 正确:按值返回
std::string make_greeting(std::string_view name) {
return std::format("Hello, {}!", name); // [正确] RVO,零拷贝
}
悬垂引用 (Dangling Reference)
永远不要返回局部变量的引用或指针。局部变量在函数返回时被销毁,引用指向的内存变成无效的。这是未定义行为(UB),程序可能崩溃、产生随机值,或"看起来正常"但随时爆炸。
4. 函数重载 (Overloading)
C++ 允许多个函数同名,只要参数列表不同(参数个数、类型、或 const/非 const):
// 重载:同名函数,不同参数
void print(int value) {
std::println("int: {}", value);
}
void print(double value) {
std::println("double: {}", value);
}
void print(std::string_view text) {
std::println("string: {}", text);
}
// 编译器根据实参类型选择最佳匹配
print(42); // 调用 print(int)
print(3.14); // 调用 print(double)
print("hello"); // 调用 print(string_view)
重载决议规则(简要)
编译器按以下优先级选择重载:
- 精确匹配:实参类型与形参类型完全一致
- 微小转换:如数组到指针、函数到函数指针
- 提升:如
short→int、float→double - 标准转换:如
int→double、派生类指针到基类指针 - 用户定义转换:通过构造函数或转换运算符
如果没有唯一最佳匹配,编译器会报"ambiguous call"错误。
// 实际场景:为不同容器类型提供统一接口
std::size_t size(const std::string& s) { return s.size(); }
std::size_t size(const char* s) { return std::strlen(s); }
template<typename T>
std::size_t size(const std::vector<T>& v) { return v.size(); }
5. 默认参数 (Default Arguments)
为参数提供默认值,调用者可以省略这些参数:
void connect(std::string_view host, int port = 8080, bool use_tls = false) {
std::println("Connecting to {}:{} (TLS: {})", host, port, use_tls);
}
// 各种调用方式
connect("localhost"); // port=8080, use_tls=false
connect("api.example.com", 443); // use_tls=false
connect("api.example.com", 443, true); // 全部指定
默认参数的规则
- 默认参数必须从右向左连续提供(不能跳过中间参数)
- 默认值只在声明中指定,定义中不要重复
- 每个翻译单元中,同一参数的默认值只能指定一次
// [错误] 错误:默认参数不能在中间
void bad(int a = 1, int b, int c = 3); // 编译错误!
// [正确] 正确:从右向左
void good(int a, int b = 2, int c = 3); // OK
// 声明(头文件)中给默认值
void log(std::string_view msg, int level = 0); // .h
// 定义(源文件)中不重复
void log(std::string_view msg, int level) { // .cpp
// ...
}
默认参数 vs 重载
如果默认行为简单明了,用默认参数更简洁。如果不同参数组合需要完全不同的逻辑,用重载更清晰。
另一个替代方案是使用带命名字段的结构体作为"选项包"(Options struct),适合参数超过 3-4 个的情况。
6. [[nodiscard]] 属性
[[nodiscard]] 告诉编译器:这个函数的返回值不应被忽略。如果调用者没有使用返回值,编译器会发出警告。
基本用法
[[nodiscard]] int compute_hash(std::string_view input) {
int hash = 0;
for (char c : input) {
hash = hash * 31 + c;
}
return hash;
}
// 正确用法
int h = compute_hash("test");
// [注意] 编译器警告:返回值被忽略!
compute_hash("test"); // 计算了但没用结果,很可能是 bug
C++20: 带原因的 [[nodiscard]]
C++20 允许附带一条说明消息,告诉调用者为什么不应忽略返回值:
[[nodiscard("Error code must be checked")]]
int send_request(std::string_view url) {
// ... 发送网络请求
return error_code;
}
// [注意] 警告信息包含原因:
// "Error code must be checked"
send_request("https://api.example.com");
什么时候用 [[nodiscard]]?
- 错误码:忽略错误码是最常见的 bug 来源
- 工厂函数:返回新建的资源,忽略即泄漏
- 纯计算:函数无副作用,不用返回值说明调用毫无意义
- 容器操作:如
empty()— 调用者可能误以为是"清空"操作
// 标准库中已有的 [[nodiscard]] 示例
// std::vector::empty() 是 [[nodiscard]],防止误用:
std::vector<int> v = {1, 2, 3};
v.empty(); // [注意] 警告!你是想检查是否为空?还是想清空?
// 如果想清空,应该用 v.clear()
// 给整个类/结构体标记
[[nodiscard]] struct ErrorCode {
int code;
std::string message;
};
ErrorCode open_file(std::string_view path);
open_file("data.txt"); // [注意] 警告:返回的 ErrorCode 被忽略
7. auto 返回类型
C++14 起,函数可以让编译器自动推导返回类型:
自动推导返回类型
// 编译器从 return 语句推导出返回类型为 int
auto add(int a, int b) {
return a + b;
}
// 多个 return 必须推导出相同类型
auto abs_value(int x) {
if (x >= 0) return x; // int
else return -x; // int — OK,类型一致
}
尾置返回类型 (Trailing Return Type)
使用 auto func() -> Type 语法,将返回类型放在参数列表之后:
// 尾置返回类型 — 返回类型在箭头后面
auto make_greeting(std::string_view name) -> std::string {
return std::format("Hello, {}!", name);
}
// 当返回类型依赖参数时特别有用
template<typename T, typename U>
auto multiply(T a, U b) -> decltype(a * b) {
return a * b;
}
什么时候用 auto 返回类型?
| 场景 | 建议 |
|---|---|
| 返回类型很明显(如 lambda、简单表达式) | 用 auto |
| 公共 API / 头文件中的接口函数 | 写明具体类型 |
| 返回类型很复杂(如迭代器、嵌套模板) | 用 auto 或尾置返回类型 |
| 模板函数中返回类型依赖参数 | 用尾置返回类型 |
注意可读性
在公共 API 中,写明返回类型让用户无需查看函数体就能理解接口。auto 返回类型更适合内部实现函数和模板。过度使用 auto 会降低代码的自文档性。
综合示例
将本章的所有技巧结合到一个实际场景中:
#include <string>
#include <string_view>
#include <vector>
#include <print>
#include <algorithm>
#include <ranges>
// [[nodiscard]] + const& 参数
[[nodiscard]]
auto find_longest(const std::vector<std::string>& words) -> std::string_view {
if (words.empty()) return {};
auto it = std::ranges::max_element(words, {},
[](const std::string& s) { return s.size(); });
return *it;
}
// 默认参数 + string_view
void print_header(std::string_view title, char border = '=', int width = 40) {
std::println("{}", std::string(width, border));
std::println(" {}", title);
std::println("{}", std::string(width, border));
}
// NRVO:放心按值返回
[[nodiscard]]
std::vector<std::string> filter_long_words(
const std::vector<std::string>& words,
std::size_t min_length = 5)
{
std::vector<std::string> result;
for (const auto& w : words) {
if (w.size() >= min_length) {
result.push_back(w);
}
}
return result; // NRVO — 不会拷贝
}
// 重载:不同类型不同处理
void describe(int value) { std::println("整数: {}", value); }
void describe(std::string_view text) { std::println("文本: \"{}\"", text); }
void describe(double value) { std::println("浮点: {:.2f}", value); }
int main() {
std::vector<std::string> words = {
"hello", "world", "magnificent", "cpp", "programming"
};
print_header("函数设计演示");
auto longest = find_longest(words);
std::println("最长单词: {}", longest);
auto long_words = filter_long_words(words);
std::println("长单词数量: {}", long_words.size());
describe(42);
describe("modern C++");
describe(3.14159);
}
本章小结
- 参数传递:小类型按值,大对象
const&,只读字符串string_view,需修改用& - 返回值:大胆按值返回,RVO/NRVO 保证高效;永远不要返回局部变量的引用
- 重载:同名函数、不同参数,编译器自动选择最佳匹配
- 默认参数:为常见调用提供便利,从右向左连续设置
- [[nodiscard]]:对错误码、纯计算等不应忽略返回值的函数使用
- auto 返回类型:简化复杂返回类型,但公共 API 应显式标注