指针：
地址、空值与有效访问。

上一章可以借一个名字访问已有整数。现在程序还需要表达“这次没有可借的对象”，或者先查看x，再去查看y。我们怎样把这份选择保存下来？更关键的是：非空地址为什么也不一定能读？ 本章先学会分清两种赋值，再判断每一次访问是否有效。

先备是新05：引用与const。五节预计7小时，含推演与编码，尚未经真人试学校准。正常程序只借用已初始化、仍存活的具名int；数值变化限定在−100到100内。不输出具体地址，不做数组算术，不申请动态内存。后面一份局部地址错误程序只读源码与编译诊断，不执行。

06.1 指针对象与取地址 · 预估90分钟

怎样保存“要访问哪一个对象”

你已经会画整数格，也会在格子旁标一个引用名。现在要再画一个格子：它保存的不是那个整数的副本，而是找到目标对象的信息。本节先逐项读声明，再沿这条关系读取或修改整数。

对本章的具名整数x，表达式&x取得x的地址（address）。地址用于指明对象所在的位置；这里不需要知道它在某次运行中的数字。int* p{&x};建立名为p的指针对象（pointer object），它的类型是int*，初值是x的地址。读作“p保存一个指向int的指针值”。x是整数对象，p是另一个保存指针值的对象。

表达式*p沿p保存的关系找到那个int，称为间接访问或解引用（indirection / dereference）。p指向仍活着的x时，读取*p得到x的整数值；*p = 7;把7写入x。这不是把p本身改成整数7。

同一个符号要结合位置读。声明里的*描述p的类型；表达式里的*要求沿指针找目标。表达式里的&取地址，不能把它读成“这里又声明了引用”。本章每条声明只写一个名字，避免把多个声明挤在一行里。

#include <iostream>

int main() {
    int x{4};
    int* p{&x};
    std::cout << *p << '\n';
    *p = 7;
    std::cout << x << ' ' << *p << '\n';
    return 0;
}

先创建x=4，再创建p并保存x的地址。第一条输出沿p找到x，得到4。赋值*p = 7改的是x，最后按x、*p输出7 7。全程只有一份整数；额外的p是指针对象，不是第二份int。

沿用新04的严格编译选项：保存文件后，可用clang++ -std=c++20 -Wall -Wextra -Wpedantic -Werror address.cpp -o address && ./address。本章故意错误的文件只执行编译命令，不接&& ./程序名，也不去启动上次留下的程序。

06.2 改值与改指向 · 预估90分钟

下一次赋值应该擦掉哪一个格子

现在加入第二个整数y。任务可能是更新x，也可能是把观察位置移到y。两者都可以用赋值，但左边的名字决定究竟改动哪一个对象。

*p = 7;写的是目标整数；p = &y;写的是指针对象p，令它保存y的地址，称为改指向（retargeting）。后一个动作不读写x或y中的整数。之后再使用*p，才会沿新的关系访问y。引用r建立后不能改绑，普通指针p则可以保存另一个合适的地址。

完整例一：先更新x，再观察y

#include <iostream>

int main() {
    int x{4};
    int y{9};
    int* p{&x};
    *p = 7;
    p = &y;
    std::cout << x << ' ' << y << ' ' << *p << '\n';
    return 0;
}

阶梯第一步：预测后只换一个动作

不运行，先画完上表。再只把最后一次赋值p = &y;改为*p = y;，保留其他语句，重新画关系和输出。

两个指针也可能借同一个整数

int* q{p};创建独立的指针对象q，从p复制指针值：建立这一刻两者指向同一个x，没有再复制一份x。随后修改p的指向不会自动修改q。只要它们指向同一个仍存活的整数，经其中任一路径改值，另一条路也能观察到新值。这是别名（aliasing）在指针上的情形。

#include <iostream>

int main() {
    int x{4};
    int y{9};
    int* p{&x};
    int* q{p};
    *p = 7;
    p = &y;
    std::cout << x << ' ' << y << ' ' << *q << ' ' << *p << '\n';
    *q = 8;
    std::cout << x << ' ' << y << ' ' << *q << ' ' << *p << '\n';
    return 0;
}

两份整数x、y，加两份指针对象p、q。先经p把x改7，再让p去指y；q仍指x，因此首行按x、y、*q、*p输出7 9 7 9。接着*q = 8改x，第二行是8 9 8 9。复制指针保存关系，后续不会让两个指针对象自动绑定在一起。

06.3 可选借用 · 预估90分钟

这次没有对象时，接口怎样表达

有时调用者能交来一个整数，有时没有。本节让同一个函数处理两条路径，并说清什么检查能防止没有目标时仍然取值。

nullptr是专门表示空指针值（null pointer value）的写法。int* p{nullptr};明确初始化p，但没有给它一个可访问的int。它不同于“p指向一个值恰好为0的整数”。指向0的对象仍有目标，解引用得到0；空指针没有这个目标，不能用*p读写。

本章用显式比较p == nullptr或p != nullptr得到已学的bool条件。先判断，再决定是否进入含*p的路径。不要先输出*p，然后才补一个判空分支。比较不能替代初始化：不使用int* p;建立一个随后未经赋值就拿来比较的指针。

先限定接口的输入合同：传入nullptr，或者传入一个已初始化、仍存活的int的地址；借用期间该对象一直活着。在这个范围内，判空后即可访问。若调用者传来已失效地址，它已经违反输入合同，判空不会修复它；06.5专门推演这个失败。

完整例二：值与missing

函数形参int* p按值接收一个指针。调用print_if_present(&value)把value的地址交给p；调用print_if_present(nullptr)则把空值交给p。前者没有复制value中的整数，后者也没有创建一个虚构的整数。

#include <iostream>

void print_if_present(int* p) {
    if (p == nullptr) {
        std::cout << "missing" << '\n';
        return;
    }
    std::cout << *p << '\n';
}

int main() {
    int value{6};
    print_if_present(&value);
    print_if_present(nullptr);
    return 0;
}

第一次p保存value的地址，判空结果为false，跳过if块并输出6。第二次p为空，进入if块，输出文本missing并执行已学的return;。函数立即结束，不到达后面的*p。这条提前返回就是本例保护访问的控制流。

阶梯第二步：补上保护访问的那一步

盖住函数体，从空文件写void print_if_present(int* p)。要求空输入输出missing且立即返回，其他符合输入合同的指针输出目标值。main至少测试值为6、值为0和nullptr三种输入。

小练习：一个会运行的错误

下面任务要求“把y当前的整数写入p原来指向的x”。实现能编译，但未必满足任务。先写实际输出，再只改一条赋值修复它。

#include <iostream>

int main() {
    int x{4};
    int y{9};
    int* p{&x};
    p = &y;
    std::cout << x << ' ' << y << ' ' << *p << '\n';
    return 0;
}

函数改了p，究竟改了谁

沿用新04的按值规则：每次调用都有独立参数对象，只是这次参数保存指针值。void set_seven(int* p)中的p和调用者的p是两份指针对象，最初指向同一目标。写*p可修改共同目标；写形参p只改本次的指针副本，不会使调用者的指针改指向。这不改变“按值参数独立”的规则。

#include <iostream>

void set_seven(int* p) {
    if (p != nullptr) {
        *p = 7;
    }
}

void point_elsewhere(int* p, int* other) {
    p = other;
    if (p != nullptr) {
        std::cout << *p << '\n';
    }
}

int main() {
    int x{4};
    int y{9};
    int* p{&x};
    set_seven(p);
    point_elsewhere(p, &y);
    std::cout << x << ' ' << y << ' ' << *p << '\n';
    return 0;
}

set_seven接收指向x的副本，判非空后把x改7。point_elsewhere中的p和other分别接收x与y的地址，p = other只让局部p改指y，所以函数内输出9。回到main，main自己的p仍指x，按x、y、*p输出7 9 7。函数名不能代替合同：这里故意显示“局部改指向”不会传播给调用者。

返回地址，与返回整数分开读

函数头int* positive_or_missing(int& value)的int*描述返回的结果类型：交回一个指向int的指针值。引用参数value仍按新05绑定调用者的整数。return &value;交回那个整数的地址；return nullptr;交回空值。调用者可以用结果初始化自己的指针，不会因此获得第二份整数。

#include <iostream>

int* positive_or_missing(int& value) {
    if (value > 0) {
        return &value;
    }
    return nullptr;
}

int main() {
    int value{6};
    int* p{positive_or_missing(value)};
    if (p != nullptr) {
        std::cout << *p << '\n';
        value = 9;
        std::cout << *p << '\n';
    }
    int zero{0};
    int* absent{positive_or_missing(zero)};
    if (absent == nullptr) {
        std::cout << "missing" << '\n';
    }
    return 0;
}

输入value=6满足大于0，p接收main中value的地址。先输出6，再通过原名把value改9，下一次*p得到9。zero=0不满足条件，absent接收nullptr，于是输出missing。value与zero都属于main，执行这些访问时仍存活；函数返回不会结束它们的寿命。

06.4 const的位置 · 预估60分钟

要固定目标，还是限制通过它写入

现在既有指针对象，又有被指向的整数。接口中的const可能限制其中不同的一层。本节先把两种允许操作分开，再看完整程序，不用凭“有const所以都不能变”来猜。

const int* read表示read可以改指向，但不能通过*read给目标赋值。它提供只读的int访问路径。int* const fixed表示fixed这个指针对象初始化后不能被赋予另一个指针值，但若目标int可写，就仍能通过*fixed修改它。const int* const both把两种限制同时加上：both不改指向，也不能经它写目标。

位于*前的const限制通过指针访问的int；位于*后的const限制指针对象本身。只读路径仍不是快照：一个可写的x可以通过原名改值，read下一次读取会看到新值。const指针也不负责延长目标寿命，固定地址不等于保证它永远有效。

取得const整数的地址，只能在本章用提供只读访问的指针接收。把&frozen放进int*会丢掉已有的限制，编译器应当拒绝。这里不引入任何绕过const的转换。

#include <iostream>

int main() {
    int x{4};
    int y{9};
    const int* read{&x};
    x = 7;
    std::cout << *read << '\n';
    read = &y;
    std::cout << *read << '\n';
    int* const fixed{&x};
    *fixed = 8;
    const int* const both{&y};
    y = 10;
    std::cout << *fixed << ' ' << *both << '\n';
    const int frozen{6};
    const int* frozen_read{&frozen};
    std::cout << *frozen_read << '\n';
    return 0;
}

read先指向x，x经原名改7，第一行是7。read再改指y，第二行是9。fixed不能改指向，但*fixed = 8合法，x变8。both不能经自己写y，y却能通过原名变10，因此第三行8 10。最后frozen本身是const，frozen_read只读它，输出6。

以下三份短文件分别违反三条已讲过的限制。先指出错误语句和受限制的层，再只编译看诊断；它们没有预期运行输出。

#include <iostream>

int main() {
    int x{4};
    const int* read{&x};
    *read = 7;
    std::cout << *read << '\n';
    return 0;
}

#include <iostream>

int main() {
    int x{4};
    int y{9};
    int* const fixed{&x};
    fixed = &y;
    std::cout << *fixed << '\n';
    return 0;
}

#include <iostream>

int main() {
    const int fixed{6};
    int* write{&fixed};
    std::cout << *write << '\n';
    return 0;
}

06.5 最后一次合法访问 · 预估90分钟

目标什么时候不再可用

指针没有被改写，是否足以保证下次仍能读？现在把目标放入一个内层块，沿已学的局部寿命规则标出它存在的区间，再决定访问应放在哪一侧。

对本章普通局部int，退出它所在块时对象寿命与那段自动存储的使用期都结束。外层指针对象仍可能存在，但它保存过的关系不会让内层整数继续存活。指向已经结束的对象的指针称为悬空指针（dangling pointer）；经它读取或写入不再有有效目标，属于未定义行为，不能为它指定一个正确输出。

下面采取主动收回借用的做法：在local仍活着时完成最后一次读取，并把外层p设为nullptr，再退出块。这只改变p，不销毁local，也不会自动清空其他指针副本；若另外保存了q，也必须单独避免让它越过目标的有效期。

#include <iostream>

int main() {
    int* p{nullptr};
    {
        int local{4};
        p = &local;
        std::cout << *p << '\n';
        p = nullptr;
    }
    if (p == nullptr) {
        std::cout << "missing" << '\n';
    }
    return 0;
}

p初始为空。内层创建local=4后把其地址交给p，输出4；接着p被清为空值；最后退出内层块，local结束。外层比较的是已经明确写入的空值，因此安全地输出missing。这段程序从未读取已经失效的指针值。

为什么本章不运行“它看起来还非空”的实验

如果删去清空语句，再离开块，local不会自动保持存活，p也不会因为目标结束就被语言保证自动改成nullptr。由此不能反推“在块外比较p就能检查安全”：在这种自动存储已经结束的情形，连复制、输出或比较失效指针值都不是本章可依赖的可移植检查。只靠一次比较是否成功，不能证明目标仍存在。

有效访问要从指针的来源与目标寿命推导。已知输入只可能是nullptr或仍存活目标时，判空有用；来源可能已失效时，p != nullptr并没有建立“目标仍活着”的事实。图中“若漏清空，旧目标已结束”是源码寿命推演，不是一次实际比较的输出。

阶梯第三步：返回局部地址为什么留不住目标

#include <iostream>

int* bad_address() {
    int local{4};
    return &local;
}

int main() {
    int* p{bad_address()};
    std::cout << *p << '\n';
    return 0;
}

这份错误文件只编译诊断，不运行。bad_address建立自己的局部local；在return语句求地址时local还活着，但离开函数后，它已结束。main接收一个指针结果没有复制local中的4，更没有延长local的寿命。随后的std::cout << *p要求访问已经结束的目标，因此不能写“预期输出4”。

本机严格Clang可能将“返回局部地址”的警告提升为编译失败。诊断依工具与选项而定；即使另一组编译选项接受了它，错误访问仍没有变合法。对照新05已学的按值返回：若任务只是交回数字，可返回int值并由调用者保存独立结果；若任务必须返回借用，则目标必须在调用者使用期间持续存活，如06.3的main对象。

阶梯第四步：独立选择一个仍存活的整数

关掉示例，从空文件写int* choose(bool first, int& left, int& right)：first为true返回left的地址，否则返回right的地址。合同要求两个引用实参都是仍存活的可写int，且调用者保留它们直到用完结果。两个引用允许绑定同一个对象；此时两条分支都返回同一对象的地址，不需要额外分支。

main建立x=2、y=9，分别用true和false取得两个指针，输出2和9。再仅把y改10，第二个指针应读到10；第一个仍读2。用普通if检查x、y与两次借用读取，错误时输出文字并return 1。除了这组输入，再测试两个参数都传x的情况。先记录自己的实现和输出，再打开下面的参考。

#include <iostream>

int* choose(bool first, int& left, int& right) {
    if (first) {
        return &left;
    }
    return &right;
}

int main() {
    int x{2};
    int y{9};
    int* first{choose(true, x, y)};
    int* second{choose(false, x, y)};
    std::cout << *first << ' ' << *second << '\n';
    y = 10;
    std::cout << *second << '\n';
    if (*first != 2 || *second != 10 || x != 2 || y != 10) {
        std::cout << "wrong result" << '\n';
        return 1;
    }
    return 0;
}

这一章的起点问题现在可以完整回答：指针值表示去哪里访问，判空只排除“没有目标”的那一种情况；真正的读取还要求那个目标仍存活且符合访问类型。每次先追踪指针从哪里来，再分别检查改指向、写目标和最后一次合法访问。能说明这三件事，才进入下一章的类与对象生命周期。