学习 C++ / 第 12.11 课

按地址传递(第 2 部分)

11 分钟阅读

本课是 12.10 -- 按地址传递。

按地址传递实现“可选”参数

按地址传递的常见用途之一,是让函数接受“可选”参数。用例子说明比文字描述更容易:

C++
#include <iostream>

void printIDNumber(const int *id=nullptr)
{
    if (id)
        std::cout << "Your ID number is " << *id << ".\n";
    else
        std::cout << "未知 ID。\n";
}

int main()
{
    printIDNumber(); // we don't know the user's ID yet

    int userid { 34 };
    printIDNumber(&userid); // we know the user's ID now

    return 0;
}

这个示例输出:

未知 ID。
ID 为 34。

在这个程序中, printIDNumber() 函数有一个按地址传递的参数,默认值为 nullptr。 在 main()中调用该函数两次。第一次调用时不知道用户 ID,因此调用 printIDNumber() 且不传实参。 id 参数默认设为 nullptr, 函数输出 未知 ID。。 第二次调用时已有有效 ID,因此调用 printIDNumber(&userid)。 id 参数接收 userid 的地址,因此函数输出 ID 为 34。。

不过,很多情况下函数重载是实现相同结果的更好选择:

C++
#include <iostream>

void printIDNumber()
{
    std::cout << "Your ID is not known\n";
}

void printIDNumber(int id)
{
    std::cout << "Your ID is " << id << "\n";
}

int main()
{
    printIDNumber(); // we don't know the user's ID yet

    int userid { 34 };
    printIDNumber(userid); // we know the user is 34

    printIDNumber(62); // now also works with rvalue arguments
    
    return 0;
}

这样有几个优点:不必担心空指针解引用,还可以传入字面量或其他右值作为实参。

改变指针参数所指向的对象

向函数传递地址时,地址会从实参复制到指针参数中(这没问题,因为复制地址很快)。 现在请看下面的程序:

C++
#include <iostream>

// [[maybe_unused]] 可消除 ptr2 已赋值但未使用的编译器警告
void nullify([[maybe_unused]] int* ptr2) 
{
    ptr2 = nullptr; // 将函数参数设为空指针
}

int main()
{
    int x{ 5 };
    int* ptr{ &x }; // ptr 指向 x

    std::cout << "ptr is " << (ptr ? "non-null\n" : "null\n");

    nullify(ptr);

    std::cout << "ptr is " << (ptr ? "non-null\n" : "null\n");
    return 0;
}

程序输出:

ptr is non-null
ptr is non-null

如你所见,修改指针参数保存的地址不会影响实参保存的地址 (ptr 仍然指向 x). 调用 nullify() 时,ptr2 会接收传入地址的副本(这里是 ptr 保存的地址,也就是 x 的地址)。 函数改变 ptr2 的指向时,只会影响 ptr2 中保存的副本。

如果想让函数修改指针实参所指向的对象,该怎么办?

按地址传递……通过引用?

可以。正如可以按引用传递普通变量,也可以按引用传递指针。 下面是同一个程序,只是将 ptr2 改为地址的引用:

C++
#include <iostream>

void nullify(int*& refptr) // refptr 现在是指针的引用
{
    refptr = nullptr; // 将函数参数设为空指针
}

int main()
{
    int x{ 5 };
    int* ptr{ &x }; // ptr 指向 x

    std::cout << "ptr is " << (ptr ? "non-null\n" : "null\n");

    nullify(ptr);

    std::cout << "ptr is " << (ptr ? "non-null\n" : "null\n");
    return 0;
}

程序输出:

ptr is non-null
ptr is null

由于 refptr 现在是指针的引用,当 ptr 作为实参传入时,refptr 会绑定到 ptr。这意味着对 refptr 的操作都会作用于 ptr。

补充说明……

由于指针引用并不常见,很容易弄混语法(是 int*& 还是 int&*?)。好消息是,如果写反了,编译器会报错,因为不能有指向引用的指针(指针必须保存对象地址,而引用不是对象)。这时交换顺序即可。

为什么不再优先使用 0 或 NULL(可选)

本小节解释为什么不再优先使用 0 或 NULL。

字面量 0 既可以解释为整型字面量,也可以解释为空指针字面量。在某些情况下意图并不明确;编译器可能把我们想表达的一种含义误认为另一种,从而导致程序行为出现意外后果。

预处理器宏 NULL 的定义并未由语言标准规定。它可以定义为 0、0L、((void*)0),或完全不同的内容。

在课程 11.1 —— 函数重载简介中,我们讨论过函数可以重载(多个函数可以同名,只要能通过参数数量或类型区分)。编译器会根据函数调用中传入的实参判断要使用哪个重载函数。

使用 0 或 NULL 时,可能会产生问题:

C++
#include <iostream>
#include <cstddef> // 用于 NULL

void print(int x) // 此函数接受整型参数
{
	std::cout << "print(int): " << x << '\n';
}

void print(int* ptr) // 此函数接受整型指针参数
{
	std::cout << "print(int*): " << (ptr ? "non-null\n" : "null\n");
}

int main()
{
	int x{ 5 };
	int* ptr{ &x };

	print(ptr);  // always calls print(int*) because ptr has type int* (good)
	print(0);    // 总是调用 print(int),因为 0 是整数字面量(希望这正是我们的意图)

	print(NULL); // 这条语句可能产生以下任一种结果:
	// call print(int) (Visual Studio does this)
	// call print(int*)
	// 会导致函数调用歧义的编译错误(gcc 和 Clang 都会这样处理)

	print(nullptr); // always calls print(int*)

	return 0;
}

在作者的机器上(使用 Visual Studio),输出结果:

print(int*): non-null
print(int): 0
print(int): 0
print(int*): null

将整数值 0 作为参数传递时,编译器会优先选择 print(int) 而不是 print(int*)。如果原本想用空指针实参调用 print(int*),就会得到意外结果。

如果 NULL 定义为值 0,print(NULL) 也会调用 print(int),而不是空指针字面量看似应该调用的 print(int*)。如果 NULL 不是定义为 0,则可能出现其他行为,例如调用 print(int*) 或编译错误。

使用 nullptr 可以消除这种歧义(它总会调用 print(int*)),因为 nullptr 只会匹配指针类型。

std::nullptr_t(可选)

由于 nullptr 可以在函数重载中与整型值区分,因此它必须具有不同类型。那么它的类型是什么? nullptr? 答案是 nullptr 的类型为 std::nullptr_t(定义在头文件 <cstddef> 中)。 std::nullptr_t 只能保存一个值: nullptr!这看似有些奇怪,但在一种情况下很有用。 如果想编写只接受 nullptr 字面量实参的函数,可以将参数设为 std::nullptr_t。

C++
#include <iostream>
#include <cstddef> // 用于 std::nullptr_t

void print(std::nullptr_t)
{
    std::cout << "in print(std::nullptr_t)\n";
}

void print(int*)
{
    std::cout << "in print(int*)\n";
}

int main()
{
    print(nullptr); // calls print(std::nullptr_t)

    int x { 5 };
    int* ptr { &x };

    print(ptr); // calls print(int*)

    ptr = nullptr;
    print(ptr); // calls print(int*) (since ptr has type int*)

    return 0;
}

在上面的示例中,函数调用 print(nullptr) 会选择 print(std::nullptr_t) 而不是 print(int*),因为不需要转换。

唯一可能有些困惑的情况是:ptr 保存值 nullptr 时调用 print(ptr)。 记住,函数重载根据类型而不是值进行匹配,而 ptr 的类型是 int*。因此会匹配 print(int*)。这种情况下不会考虑 print(std::nullptr_t),因为指针类型不会隐式转换为 std::nullptr_t。

你可能永远不需要使用这一点,但了解它总是有益的。

只有按值传递

现在你已经理解按引用、按地址和按值传递的基本区别,让我们暂时把问题简化一下:

虽然编译器通常可以完全优化掉引用,但有些情况下做不到,此时确实需要引用。编译器通常使用指针实现引用。这意味着在幕后,按引用传递本质上就是按地址传递。

上一课提到,按地址传递只是把地址从调用者复制到被调用函数——本质上是按值传递地址。

因此可以得出结论:C++ 实际上把所有东西都按值传递! 按地址(和按引用)传递的特性,完全来自于可以解引用传入的地址来修改实参,而普通值参数做不到这一点!

最后更新