如何合法实现C++中可选的const引用参数传递？

这个问题在C里很常见——既要严格遵守const引用的契约（不能随意修改引用指向），又要实现参数的可选性，完全没必要用全局对象这种不够优雅的方式。下面给你几个更合理的方案，覆盖不同C版本的需求：

方案1：用std::optional<const ErrorCode&>（C++17及以上） #

这是最现代、语义最清晰的方案，std::optional就是专门用来表示“值存在或不存在”的类型，完美适配你的场景。你可以把参数声明为可选的const引用，默认值设为std::nullopt，调用时可传可不传。

示例代码：

#include <optional>
#include <iostream>

struct ErrorCode {
    int code;
    const char* msg;
};

class MyClass {
public:
    void do_stuff(std::optional<const ErrorCode&> err = std::nullopt) {
        if (err) {
            // 处理错误码逻辑
            std::cout << "Error detected: Code " << err->code << ", " << err->msg << std::endl;
        } else {
            // 不检查错误码的核心逻辑
            std::cout << "Executing core logic without error check" << std::endl;
        }
    }
};

int main() {
    MyClass obj;
    ErrorCode not_found_err{404, "Resource not found"};

    obj.do_stuff(); // 不传错误码，使用默认值
    obj.do_stuff(not_found_err); // 传入错误码对象
    return 0;
}

优点：语义直观，类型安全，完全符合const契约，不需要额外的全局对象。唯一限制是需要C++17或更高版本的编译器支持。

方案2：用const指针（兼容所有C++版本） #

如果你的项目还在使用C++11甚至更早的标准，const指针是个经典且可靠的选择。指针天然支持空值（nullptr），加上const修饰后，同样能保证你不会修改传入的错误码对象，完全符合const契约。

示例代码：

#include <iostream>

struct ErrorCode {
    int code;
    const char* msg;
};

class MyClass {
public:
    void do_stuff(const ErrorCode* err = nullptr) {
        if (err != nullptr) {
            // 处理错误码
            std::cout << "Error detected: Code " << err->code << ", " << err->msg << std::endl;
        } else {
            // 核心逻辑
            std::cout << "Executing core logic without error check" << std::endl;
        }
    }
};

int main() {
    MyClass obj;
    ErrorCode not_found_err{404, "Resource not found"};

    obj.do_stuff(); // 不传参数，默认nullptr
    obj.do_stuff(&not_found_err); // 传入错误码的地址
    return 0;
}

优点：兼容性拉满，所有C++版本都支持，逻辑简单易懂。小缺点：调用时需要取地址，语义上不如std::optional那么直接，但只要用const修饰指针，就能明确表达“不会修改对象”的意图。

方案3：重载成员函数 #

如果你不想用指针或std::optional，提供两个重载版本的成员函数也是个不错的选择——一个带const引用参数，一个不带。这种方式语义最明确，调用者一眼就能知道有两种调用方式。

示例代码：

#include <iostream>

struct ErrorCode {
    int code;
    const char* msg;
};

class MyClass {
private:
    // 抽离公共核心逻辑，避免代码重复
    void core_logic() {
        std::cout << "Executing core logic" << std::endl;
    }

public:
    // 不带错误码的版本
    void do_stuff() {
        core_logic();
    }

    // 带错误码的版本
    void do_stuff(const ErrorCode& err) {
        core_logic();
        // 处理错误码
        std::cout << "Error detected: Code " << err.code << ", " << err.msg << std::endl;
    }
};

int main() {
    MyClass obj;
    ErrorCode not_found_err{404, "Resource not found"};

    obj.do_stuff(); // 调用无参数版本
    obj.do_stuff(not_found_err); // 调用带错误码的版本
    return 0;
}

优点：完全符合const契约，调用方式最直观，没有额外语法负担。注意点：如果函数逻辑复杂，一定要把公共部分抽成私有函数，避免代码冗余。

为什么不推荐全局对象？ #

你提到的全局对象方案确实存在不少问题：首先全局对象会引入潜在的线程安全风险；其次它会增加代码的耦合性，让依赖关系变得不清晰；最重要的是，为了一个可选参数去维护一个全局的“空”错误码对象，完全是没必要的冗余设计——上面的三种方案都能更优雅、更安全地解决问题。

内容的提问来源于stack exchange，提问作者arynaq