如何让编译器强制要求访问Result结构体成员前先检查success？

你的需求是在无运行时开销的前提下，让编译器强制要求调用者必须先检查success成员，才能访问value或error，这可以通过以下几种方案实现：

方案一：拆分状态为独立类型（最可靠的编译期强制） #

将成功、失败的结果拆分为不同的结构体，用std::variant包装，利用C++类型系统强制调用者判别状态后再访问对应值，完全无运行时开销。

代码实现 #

#include <variant>
#include <iostream>

struct SuccessResult { float value; };
struct ErrorResult { int error; };

using Result = std::variant<SuccessResult, ErrorResult>;

Result getValue(bool somePrecondition) {
  if (somePrecondition) {
    return SuccessResult{0.5f};
  }
  return ErrorResult{-1};
}

int main() {
  auto r = getValue(true);
  
  // 必须先判别状态，否则无法合法访问成员
  if (std::holds_alternative<SuccessResult>(r)) {
    std::cout << std::get<SuccessResult>(r).value << "\n"; // 合法
  } else {
    std::cout << std::get<ErrorResult>(r).error << "\n"; // 合法
  }

  // 强制覆盖所有分支的写法（编译期检查是否遗漏状态）
  std::visit([](auto&& res) {
    using T = std::decay_t<decltype(res)>;
    if constexpr (std::is_same_v<T, SuccessResult>) {
      std::cout << "Success: " << res.value << "\n";
    } else if constexpr (std::is_same_v<T, ErrorResult>) {
      std::cout << "Error: " << res.error << "\n";
    }
  }, r);

  // 以下写法编译期允许但运行时会抛异常（编译器可通过警告提示）
  // std::cout << std::get<SuccessResult>(r).value;
  return 0;
}

优势 #

• 编译器强制要求必须先判别变体类型，完全避免非法访问
• std::variant的内存开销极小（仅比原union多一个判别式，通常是4字节，对齐后内存占用和原结构体基本一致）
• 支持编译期分支检查（if constexpr），确保所有状态都被处理

方案二：自定义编译期检查的结构体（保留union布局） #

如果要保留原union的内存布局，可以通过私有成员和标记类型，在编译期常量场景下强制检查success，运行时场景则依赖编译器警告辅助。

代码实现 #

#include <utility>
#include <iostream>

struct Result {
private:
  bool success_;
  union {
    float value_;
    int error_;
  };

  // 仅Result可构造的检查标记
  struct CheckedTag {};

public:
  // 构造函数
  constexpr Result(bool success, float value) : success_(true), value_(value) {}
  constexpr Result(bool success, int error) : success_(false), error_(error) {}

  // 返回success状态同时生成检查标记
  [[nodiscard]] constexpr std::pair<bool, CheckedTag> is_success() const {
    return {success_, CheckedTag{}};
  }

  // 仅持有标记时才能访问value（编译期常量场景强制检查）
  constexpr float value(CheckedTag) const {
    static_assert(std::is_constant_evaluated() ? success_ : true,
                  "非法访问：仅success为true时可访问value");
    return value_;
  }

  // 仅持有标记时才能访问error（编译期常量场景强制检查）
  constexpr int error(CheckedTag) const {
    static_assert(std::is_constant_evaluated() ? !success_ : true,
                  "非法访问：仅success为false时可访问error");
    return error_;
  }
};

constexpr Result getConstexprValue(bool precondition) {
  return precondition ? Result{true, 0.5f} : Result{false, -1};
}

int main() {
  // 编译期常量场景：非法访问会直接编译失败
  constexpr auto constexprRes = getConstexprValue(true);
  auto [constSuccess, constTag] = constexprRes.is_success();
  if (constSuccess) {
    std::cout << constexprRes.value(constTag) << "\n";
  }

  // 运行时场景：依赖编译器警告（如GCC的-Wanalyzer-use-of-uninitialized-value）
  auto runtimeRes = getConstexprValue(false);
  auto [runSuccess, runTag] = runtimeRes.is_success();
  if (!runSuccess) {
    std::cout << runtimeRes.error(runTag) << "\n";
  }

  return 0;
}

优势 #

• 保留原union的内存布局，无额外内存开销
• 编译期常量场景下完全强制检查，运行时场景可通过编译器警告辅助

方案三：静态分析工具/编译器扩展 #

如果不想修改结构体设计，可以借助编译器的静态分析功能或第三方工具实现检查：

• Clang静态分析器：可编写自定义规则，检查访问value/error前是否已检查success
• GCC警告：启用-Wanalyzer-use-of-uninitialized-value，当访问未初始化的union成员时会触发警告
• Cppcheck：编写自定义规则，识别并禁止未检查success就访问成员的代码

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