函数设计

函数是 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)

重载决议规则(简要)

编译器按以下优先级选择重载:

  1. 精确匹配:实参类型与形参类型完全一致
  2. 微小转换:如数组到指针、函数到函数指针
  3. 提升:如 short → int、float → double
  4. 标准转换:如 int → double、派生类指针到基类指针
  5. 用户定义转换:通过构造函数或转换运算符

如果没有唯一最佳匹配,编译器会报"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 应显式标注