C++17：为双向std::variant构建运算符的最优方案

兄弟，你现在用std::variant定义Length类型并实现运算符的方式确实太冗余了，嵌套多层std::visit和if constexpr不仅写起来麻烦，维护起来也头疼。我给你几个更优雅的优化方案，既能大幅简化代码，还能保持甚至提升运行效率：

1. 用双参数std::visit消除嵌套逻辑 #

std::visit本身支持同时访问多个std::variant对象，完全不需要嵌套两层visit+一堆类型判断。我们可以把通用的双variant访问逻辑抽成一个工具函数，然后每个运算符只需要传入对应的操作即可：

#include <variant>
#include <stdexcept>

// 假设你的Fraction类已经定义并重载了必要的运算符
class Fraction {
    // 你的Fraction实现...
};

using Length = std::variant<int, long, float, double, Fraction>;

// 通用二元操作工具函数
template<typename BinaryOp>
Length apply_binary_op(const Length& lhs, const Length& rhs, BinaryOp op) {
    return std::visit(
        [&](const auto& a, const auto& b) -> Length {
            // 直接调用传入的操作，只要a和b的运算符已重载就自动生效
            return op(a, b);
        },
        lhs, rhs
    );
}

// 乘法运算符实现
Length operator*(Length lhs, Length rhs) {
    return apply_binary_op(lhs, rhs, [](const auto& a, const auto& b) {
        return a * b;
    });
}

// 加法运算符实现
Length operator+(Length lhs, Length rhs) {
    return apply_binary_op(lhs, rhs, [](const auto& a, const auto& b) {
        return a + b;
    });
}

// 减法同理
Length operator-(Length lhs, Length rhs) {
    return apply_binary_op(lhs, rhs, [](const auto& a, const auto& b) {
        return a - b;
    });
}

这个写法直接把所有类型组合的处理交给std::visit的编译期分发，完全不需要手动判断类型，代码量直接砍到原来的几分之一。

2. 比较运算符的简化实现 #

比较运算符的逻辑可以复用同样的思路，注意不同类型之间的比较需要你的Fraction类支持与基础类型的比较重载：

// 相等判断
bool operator==(const Length& lhs, const Length& rhs) {
    return std::visit(
        [](const auto& a, const auto& b) -> bool {
            return a == b;
        },
        lhs, rhs
    );
}

// 不等判断直接复用相等逻辑
bool operator!=(const Length& lhs, const Length& rhs) {
    return !(lhs == rhs);
}

// 大于判断
bool operator>(const Length& lhs, const Length& rhs) {
    return std::visit(
        [](const auto& a, const auto& b) -> bool {
            return a > b;
        },
        lhs, rhs
    );
}

// 大于等于、小于、小于等于同理，直接复用>或==逻辑即可
bool operator>=(const Length& lhs, const Length& rhs) {
    return lhs > rhs || lhs == rhs;
}

bool operator<(const Length& lhs, const Length& rhs) {
    return !(lhs >= rhs);
}

bool operator<=(const Length& lhs, const Length& rhs) {
    return !(lhs > rhs);
}

3. 效率与额外优化 #

• 效率方面：这种写法和你原来的嵌套visit效率完全一致，甚至可能更好——因为std::visit的双参数版本是编译期生成的分发逻辑，和手动写if constexpr的分支没有区别，但编译器更容易对简洁的泛型代码做优化。
• 错误处理：比如除法的除零问题，可以在对应的lambda里针对性处理：

  Length operator/(Length lhs, Length rhs) {
      return apply_binary_op(lhs, rhs, [](const auto& a, const auto& b) {
          // 对算术类型判断除零
          if constexpr (std::is_arithmetic_v<decltype(b)>) {
              if (b == 0) {
                  throw std::runtime_error("Division by zero");
              }
          }
          // 对Fraction类型判断是否为零（假设Fraction有is_zero方法）
          else if constexpr (std::is_same_v<decltype(b), Fraction>) {
              if (b.is_zero()) {
                  throw std::runtime_error("Division by zero");
              }
          }
          return a / b;
      });
  }
  

• 类型提升：如果需要自定义类型提升规则（比如int*long返回long而不是int），只要你的运算符重载本身遵循了这个规则，代码就会自动生效；如果需要强制提升，可以在lambda里用decltype(auto)或者手动指定返回类型。

总结 #

这种方式把重复的std::visit逻辑抽成通用工具，每个运算符只需要关注具体的操作逻辑，代码可读性、可维护性大幅提升，同时完全不牺牲效率。只要你的Fraction类和基础类型的运算符重载都正确实现，所有类型组合的运算都会自动被处理。

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