第二章:过程式编程与安全的函数接口

本章沿着 Fibonacci 函数的改进过程,理解输入检查、对象生命周期、资源归属与结果复用,再学习函数指针、默认实参、分离编译、重载和函数模板。示例采用 C++17;不同方案用于比较,不应把所有同名版本放在同一程序中。

1. 用职责清楚的函数分解任务

过程式编程把任务拆成函数,通过参数接收输入、通过返回值或输出参数报告结果。函数应具有明确职责,让调用者知道支持什么输入、如何判断失败、结果由谁管理。

以 Fibonacci 数列 1、1、2、3、5……为例,位置从 1 开始:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
bool fibon_elem(int pos, int& result) {
    result = 0;
    if (pos <= 0 || pos > 46) return false;
    int previous = 1, current = 1;
    for (int i = 3; i <= pos; ++i) {
        int next = previous + current;
        previous = current;
        current = next;
    }
    result = current;
    return true;
}
1
2
3
4
5
6
int value = 0;
if (fibon_elem(7, value)) {
    // value 为 13
} else {
    // 输入不在支持范围内,value 为 0
}

bool 表示是否成功,引用参数承载计算结果。上限 46 建立在使用 32 位有符号 int 的假设上:第 46 项可表示,第 47 项会超出范围。不要把它当作任意整数类型通用的上限。

计算先检查输入,循环中始终维护相邻两项。一次查询为 O(pos) 时间、O(1) 额外空间;重复查询会重复计算,可以进一步缓存。

2. 作用域不等于对象生命周期

1
2
3
4
5
// 错误示例,不要使用
std::vector<int>* badSequence() {
    std::vector<int> values{1, 1, 2};
    return &values;
}

values 是普通局部对象,函数返回时已经析构。返回的地址不能延长它的生命周期,解引用会产生未定义行为。返回局部对象的引用也有相同问题。

对象种类名称可见范围生命周期特点
普通局部对象所在块通常进入声明处创建,离开块销毁
局部 static 对象所在块初始化后跨调用存在,正常终止时销毁
命名空间作用域对象相应命名空间作用域具有静态存储期
动态对象通过指针等访问从创建持续到对应销毁,不跟随局部指针离开作用域自动销毁

“局部变量通常放在栈上、动态存储通常来自堆”是常见实现模型,语言层面应优先依据存储期与生命周期判断正确性。静态存储对象也可以是 string、vector 等类对象,不只是基本类型。

3. new、delete 与资源归属

1
2
3
4
5
6
7
int* one = new int(42);
delete one;
one = nullptr;

int* array = new int[10]{};  // 10 个零初始化的 int
delete[] array;
array = nullptr;

new 表达式取得存储并初始化对象;delete 表达式销毁对象并释放相应存储。裸指针离开作用域不会自动释放动态对象,遗漏释放会造成内存泄漏。

创建方式对应释放
new Tdelete p
new T[n]delete[] p
malloc 分配存储free(p),不自动构造或析构 C++ 对象

不能混用这些分配和释放方式。delete nullptr 合法;释放后把一个指针设为空,也不会修复其他仍指向旧资源的别名。

1
2
3
using Lines = std::string[4];
std::string* p = new Lines;
delete[] p;  // 类型别名隐藏了数组,但仍必须按数组释放

new 表达式与 operator new

new std::string("Hello") 是语言表达式,通常先调用分配函数取得原始存储,再构造 string。operator new 是可以被替换或重载的分配函数,自己不负责调用 string 构造函数。两者不是同一个层次。

普通抛异常的 new 分配失败时抛出 std::bad_alloc:

1
2
3
4
5
6
7
8
#include <new>
#include <iostream>
try {
    int* p = new int[1000]{};
    delete[] p;
} catch (const std::bad_alloc& e) {
    std::cerr << e.what() << '\n';
}

此片段放在函数体内。若申请成功后的其他操作可能抛异常,手动 delete 可能执行不到,应让容器或智能指针负责清理。

4. Placement new:在已有存储中构造对象

普通 new 通常负责申请存储并构造;placement new 在调用者提供的合适存储中构造对象。

1
2
3
4
5
6
7
#include <new>
#include <string>
using S = std::string;
// 以下放在函数体内
// alignas(S) unsigned char storage[sizeof(S)];
// S* p = new (storage) S("Hello");
// p->~S();

存储必须大小足够、对齐正确。显式析构结束对象生命周期,但不释放外部提供的存储,不能在这里 delete p。string 内部仍可能自行申请内存,因此 placement new 不意味着整个操作完全没有动态分配。此技术用于底层资源管理,日常代码优先使用普通对象和标准容器。

5. 安全返回结果的三种方案

按值返回:调用者拥有独立结果

1
2
3
4
5
6
7
8
9
#include <vector>
std::vector<int> makeSequence(int length) {
    if (length <= 0 || length > 46) return {};
    std::vector<int> values(length);
    for (int i = 0; i < length; ++i) {
        values[i] = i < 2 ? 1 : values[i - 1] + values[i - 2];
    }
    return values;
}

返回对象本身与返回其地址不同。按值返回是安全的,编译器可以利用返回值优化或移动,不能简单认定它“一定会复制整个容器,因此很慢”。此接口约定空结果表示非法输入。

动态分配:明确交出所有权

1
2
3
4
std::vector<int>* makeOwnedSequence(int length) {
    if (length <= 0 || length > 46) return nullptr;
    return new std::vector<int>(makeSequence(length));
}

成功后调用者负责释放。这里 new 创建的是一个 vector 对象,哪怕它内部有多个 int,也必须用 delete p,不是 delete[] p。

1
2
3
#include <memory>
// std::unique_ptr<std::vector<int>> p(makeOwnedSequence(8));
// if (p) { /* 使用 (*p)[7],结果为 21 */ }

unique_ptr 在离开作用域时自动清理,也能处理异常离开。实际接口通常优先按值返回容器;确需动态独占所有权时,可直接返回 unique_ptr,避免把手动释放责任隐含在裸指针中。

局部 static:返回共享缓存的借用入口

1
2
3
4
5
6
7
8
const std::vector<int>* cachedSequence(int length) {
    static std::vector<int> values;
    if (length <= 0 || length > 46) return nullptr;
    for (int i = static_cast<int>(values.size()); i < length; ++i) {
        values.push_back(i < 2 ? 1 : values[i - 1] + values[i - 2]);
    }
    return &values;
}

第一次查 5 项,计算前 5 项;再查 8 项,只追加 3 项;随后查 3 项,缓存仍有 8 项。成功时保证至少包含请求数量,调用者只读取所需前缀。

返回的是借用指针,不能 delete。vector 对象地址跨调用有效,但追加导致扩容时,原先取得的元素地址或迭代器可能失效。const 指针限制调用者通过它修改缓存,并不保证以后查询不会改变共享内容。

C++11 保证函数局部 static 的初始化具有相应线程安全保证,但后续对同一个 vector 的并发读写不会自动安全。

方案谁管理结果是否复用历史计算
按值返回返回对象自动管理上述实现不复用
动态分配所有者负责释放,宜使用智能指针上述实现不复用
局部 static 缓存函数内部持有,调用者借用复用并按需扩展

6. 内联函数与函数职责拆分

1
2
3
inline bool validLength(int length) {
    return length > 0 && length <= 46;
}

把检查提取为函数,能让生成数列的函数专注于计算。inline 不保证编译器展开调用,也不是“加上就一定更快”。编译器按优化条件决定是否展开;展开可能减少调用成本,也可能增大代码体积。

inline 的重要语言作用是允许满足规则的定义存在于多个翻译单元。定义通常放在头文件,并保证各处定义满足一致性要求;不要在包含该头文件的源文件中再次重复定义。

7. 函数指针:把变化的算法作为参数

假设不同数列生成函数都使用相同接口:接收长度,返回共享数列的只读指针。共同的“检查位置、调用生成函数、取出元素”逻辑可以写一次。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
using Sequence = const std::vector<int>* (*)(int);

bool sequenceElement(int pos, int& result, Sequence generator) {
    result = 0;
    if (!generator || pos <= 0) return false;
    const auto* sequence = generator(pos);
    if (!sequence || static_cast<std::size_t>(pos) > sequence->size()) {
        return false;
    }
    result = (*sequence)[pos - 1];
    return true;
}
1
2
3
Sequence generator = cachedSequence;
int result = 0;
sequenceElement(6, result, generator);  // result 为 8

const std::vector<int>* (*generator)(int) 表示指向函数的指针;函数接收 int,返回 const vector*。围住 *generator 的括号不可省略,否则会改变声明含义。函数名通常可自动转换为相应函数指针,调用时可以直接写 generator(pos)。

1
2
Sequence generators[] = {cachedSequence};
// 若还有接口相同的三角数、平方数生成函数,可放入同一数组

函数指针数组可以根据枚举或索引选择算法;使用前必须检查索引范围。函数签名必须兼容,不是只要功能相似就能放进来。不要为了兼容强制转换不匹配的函数指针。

8. 默认实参:常用情况可以省略

1
2
3
4
5
#include <iostream>
void display(const std::vector<int>& values,
             std::ostream& out = std::cout) {
    for (int value : values) out << value << '\n';
}

调用 display(values) 使用 cout,display(values, file) 使用指定文件流。若参数需要表达“不提供输出对象”,可以选择指针:

1
2
3
4
5
void debugDisplay(const std::vector<int>& values,
                  std::ostream* out = nullptr) {
    if (!out) return;
    for (int value : values) *out << value << '\n';
}

引用需要绑定对象,不能写 std::ostream& out = 0 来表示没有输出。

在通常的单个声明中,某个普通参数有默认实参后,右侧参数也需要有默认实参。默认实参在同一作用域中不能重复指定,通常只写在头文件声明处,源文件定义不重复。默认实参不是函数指针类型的一部分,也不能直接用于通过函数指针的调用。

9. 头文件与分离编译

头文件声明接口,源文件定义实现,使用方包含头文件:

1
2
3
4
5
// math_utils.h
#ifndef MATH_UTILS_H
#define MATH_UTILS_H
int add(int a, int b);
#endif
1
2
3
// math_utils.cpp
#include "math_utils.h"
int add(int a, int b) { return a + b; }
1
2
3
// main.cpp
#include "math_utils.h"
int main() { return add(1, 2) == 3 ? 0 : 1; }

把 main.cpp 和 math_utils.cpp 一起编译链接。include 使声明对当前翻译单元可见,并不会自动编译链接相应的 .cpp。头文件保护避免重复包含;普通非 inline 函数定义一般放在一个源文件中,防止链接时重复定义。

10. 函数重载与歧义

1
2
3
void show(int value);
void show(double value);
void show(int value, int base);

重载在编译期根据参数数量、类型和转换等规则选择唯一最佳匹配。不能只靠返回类型区分,也不能只靠形参名称区分。按值参数的顶层 const 不区分重载:void f(int) 与 void f(const int) 声明同一函数。

1
2
3
void print(char);
void print(char, char = 'B');
// print('A');  // 歧义:两者都能很好地匹配

声明本身可以合法,但调用可能歧义。默认实参与隐式转换会扩大可匹配范围,应让接口尽量清晰。

11. 函数模板:把类型作为参数

当算法相同、只是元素类型不同,可写模板避免为 int、double、string 分别复制实现。

1
2
3
4
5
template <typename T>
void displayValues(const std::vector<T>& values,
                   std::ostream& out = std::cout) {
    for (const T& value : values) out << value << '\n';
}
1
2
3
4
// std::vector<int> numbers{1, 2, 3};
// displayValues(numbers);  // 根据实参推导 T 为 int
// std::vector<std::string> words{"Hello", "C++"};
// displayValues(words);    // 推导 T 为 std::string

模板不是“任意类型都能用”。T 必须支持实现中使用的操作,这里要求元素能通过 out « value 输出。编译器在编译时按所需类型实例化相应版本,不是每调用一次就动态生成新函数。

模板定义通常放在头文件,让实例化处能看到完整实现;只把声明放进头文件而把定义藏在普通 .cpp 中,往往会造成所需实例缺失,除非使用显式实例化等特定安排。

技术解决的问题
默认实参一个操作中,常见参数可以省略
函数重载相关操作需要不同参数接口或实现
函数模板同一算法适用于满足条件的不同类型
函数指针运行时可以选择接口相同的具体函数

复习重点

能说明为什么不能返回普通局部对象的地址;能区分拥有与借用,并匹配 new/delete;能比较按值返回、动态对象和局部静态缓存;能读写基本函数指针类型;能判断默认实参、重载与模板适合解决的问题。

前置知识:第一章。模板如何与迭代器、容器及算法结合,见 第三章。

使用 Hugo 构建
主题 Stack 由 Jimmy 设计