C++17 std::variant与std::visit实战：告别臃肿条件判断，实现高效类型安全多态-北京尧图网络

1. 项目概述为什么我们需要告别复杂的条件判断在C的世界里处理多种可能类型的对象比如解析JSON数据、处理网络协议包或者管理UI事件我们传统上会怎么做无非就是那几板斧用union配合一个enum标签小心翼翼地管理内存和类型或者用基类指针加动态类型转换dynamic_cast写出一长串if-else if链代码又臭又长还容易出错。每次加一个新类型都得在所有判断分支里再添一笔维护起来简直是噩梦。更别提性能上那一连串的条件判断和虚函数调用在性能敏感的场合看着就让人揪心。C17带来的std::variant和std::visit就是为了根治这个“老毛病”而来的。你可以把std::variant理解成一个类型安全的、现代化的“超级union”。它能在编译期就确保你放入和取出的类型是它声明时允许的几种之一彻底告别了手动管理类型标签和内存对齐的繁琐与危险。而std::visit则是访问这个“类型盒子”里具体值的“万能钥匙”。它最精妙的地方在于能够根据variant当前实际存储的类型自动调用对应的处理函数这个过程在编译期就通过模板和访问者模式被安排得明明白白运行时几乎没有额外开销。所以这个“从入门到精通”的过程目标非常明确就是让你彻底掌握如何用variant和visit这对黄金组合来优雅地替换掉项目中那些臃肿不堪的switch-case和if-else链。这不仅仅是语法糖更是一种思维模式的转变——从命令式的“我问你答”类型判断转向声明式的“你是什么我就做什么”类型分发。对于从事游戏开发处理不同的游戏实体状态、高频交易处理不同的市场数据报文、嵌入式系统处理不同的传感器数据或者任何需要处理多态数据的C开发者来说这都是必须装备的核心技能。2. 核心概念解析variant与visit如何协同工作2.1 std::variant一个类型安全的联合体std::variantTypes...是一个类模板它可以持有其模板参数列表中任意一种类型的值。例如std::variantint, float, std::string这个对象在某一时刻要么存着一个int要么存着一个float要么存着一个std::string。它内部自己管理类型标签你不需要自己定义一个enum来记录当前类型。它的几个核心特性决定了其强大与安全类型安全你无法取出一个未当前存储类型的值尝试这样做会抛出std::bad_variant_access异常。这比裸union安全得多。值语义它通常管理其包含对象的值支持拷贝、移动等操作。当variant的类型改变时旧值会被正确析构新值会被构造。可查询状态通过index()方法可以获取当前存储类型在模板参数列表中的索引从0开始。valueless_by_exception()可以查询是否因为异常而处于无值状态。空间效率其大小通常是对齐后最大类型的大小加上一个小的类型标签开销内存布局紧凑。一个简单的声明和赋值例子#include variant #include string #include iostream int main() { // 定义一个可以容纳int, double, string的variant std::variantint, double, std::string v; v 42; // 当前持有int std::cout Holds int: std::getint(v) std::endl; v 3.14159; // 现在持有double之前的int被销毁 std::cout Holds double: std::getdouble(v) std::endl; v Hello, variant!; // 现在持有std::stringdouble被销毁 // std::cout std::getint(v) std::endl; // 错误运行时抛出std::bad_variant_access std::cout Holds string: std::getstd::string(v) std::endl; // 安全地获取值使用std::get_if if (auto* pstr std::get_ifstd::string(v)) { std::cout Safely got string: *pstr std::endl; } return 0; }注意std::getT(v)在类型T不是当前持有类型时会抛出异常。在不确定类型时应优先使用std::get_ifT(v)它返回指针失败时返回nullptr或者使用我们接下来要讲的std::visit。2.2 std::visit访问variant的通用访问者std::visit是一个函数模板它接受一个“访问者”Callable对象如函数、lambda表达式、重载了operator()的类对象和一个或多个std::variant对象。它的核心职责是在运行时根据variant实际存储的类型自动调用访问者中对应类型的重载版本。这个“自动调用对应类型”的魔法是通过C的模板和编译期多态实现的。访问者必须能够处理variant可能持有的所有类型。对于多个variant的情况visit会处理所有可能的类型组合。最简单的使用方式是用一个泛型lambdaauto visitor [](auto arg) { using T std::decay_tdecltype(arg); if constexpr (std::is_same_vT, int) { std::cout Processing int: arg std::endl; } else if constexpr (std::is_same_vT, double) { std::cout Processing double: arg std::endl; } else if constexpr (std::is_same_vT, std::string) { std::cout Processing string: arg std::endl; } }; std::variantint, double, std::string v test; std::visit(visitor, v); // 输出Processing string: test这里使用了C17的if constexpr在编译期进行条件判断确保只有匹配当前类型的代码分支会被实例化和编译。这是实现“类型分发”的关键技巧之一。2.3 协同工作机制剖析variant和visit的配合本质上实现了**“双重分发”**。第一重分发在运行时visit查看variant的当前类型索引。第二重分发在编译期根据这个类型索引编译器将调用解析到访问者中对应类型的处理函数上。对于简单的访问者编译器可以做得极其高效甚至可能将调用优化为直接跳转或内联性能逼近手写的switch语句但代码却清晰、安全、易扩展得多。3. 从基础到进阶visit的四种实战用法掌握std::visit的关键在于理解并灵活运用其访问者的多种形式。不同的形式适用于不同的场景从快速原型到复杂系统你总能找到合适的一种。3.1 用法一泛型Lambda与if constexpr最常用这是最灵活、最直观的方式尤其适合类型处理逻辑有较多共性但又有一些特殊分支的情况。如上例所示在一个泛型Lambda中使用if constexpr和类型特征std::is_same_v,std::is_integral_v等来区分处理逻辑。实战示例统一打印日志假设我们有一个网络数据包variant可能是Header、DataPacket或ErrorMsg。我们需要统一打印日志但格式略有不同。struct Header { int seq; int cmd; }; struct DataPacket { std::vectorchar data; }; struct ErrorMsg { int code; std::string info; }; using NetworkPacket std::variantHeader, DataPacket, ErrorMsg; void logPacket(const NetworkPacket packet) { auto logger [](auto arg) { using T std::decay_tdecltype(arg); std::cout [LOG] ; if constexpr (std::is_same_vT, Header) { std::cout Header - seq: arg.seq , cmd: arg.cmd; } else if constexpr (std::is_same_vT, DataPacket) { std::cout DataPacket - size: arg.data.size() bytes; } else if constexpr (std::is_same_vT, ErrorMsg) { std::cout ErrorMsg - code: arg.code , info: arg.info; } std::cout std::endl; }; std::visit(logger, packet); }优点逻辑集中易于阅读和修改。可以利用if constexpr实现编译期条件编译避免无关分支的代码生成。缺点当类型很多且处理逻辑完全独立、毫无共性时Lambda会变得庞大。此时可考虑下一种方法。3.2 用法二重载函数对象经典访问者模式这是标准库文档中经典的方式它显式地定义了每个类型的处理操作结构非常清晰。你需要创建一个类为其重载多个operator()每个重载对应variant中的一种类型。实战示例几何图形面积计算struct Circle { double radius; }; struct Rectangle { double width; double height; }; struct Triangle { double a; double b; double c; }; // 简单起见假设为直角三角形 using Shape std::variantCircle, Rectangle, Triangle; // 定义访问者类 struct AreaCalculator { double operator()(const Circle c) const { return 3.14159 * c.radius * c.radius; } double operator()(const Rectangle r) const { return r.width * r.height; } double operator()(const Triangle t) const { // 海伦公式或直角边公式此处简化 return 0.5 * t.a * t.b; } }; int main() { Shape s1 Circle{2.0}; Shape s2 Rectangle{3.0, 4.0}; AreaCalculator calc; std::cout Circle area: std::visit(calc, s1) std::endl; std::cout Rectangle area: std::visit(calc, s2) std::endl; return 0; }优点结构清晰职责分离。访问者类可以独立测试、复用甚至可以通过继承来扩展。缺点需要单独定义一个类代码量稍多。C17提供了std::overloaded来简化创建但需要自己定义或使用C20的std::variant配套工具。3.3 用法三使用std::overloaded简化重载集合C17/20技巧手动定义访问者类有些繁琐。我们可以利用模板技巧创建一个overloaded类模板它能够继承一组lambda或函数对象并将它们的operator()通过using声明引入形成一组重载。// 一个通用的overloaded模板 templateclass... Ts struct overloaded : Ts... { using Ts::operator()...; }; // 推导指引C17起需要 templateclass... Ts overloaded(Ts...) - overloadedTs...; // 使用 Shape shape Triangle{3, 4, 5}; double area std::visit(overloaded{ [](const Circle c) { return 3.14159 * c.radius * c.radius; }, [](const Rectangle r) { return r.width * r.height; }, [](const Triangle t) { return 0.5 * t.a * t.b; } }, shape);这种方式结合了Lambda的便捷和重载的清晰是社区中非常流行的写法。如果你的项目尚未引入C20可以自己定义这个overloaded模板。3.4 用法四处理多个variant多维分发std::visit的强大之处还在于它能同时处理多个variant实现多维类型分发。这在处理需要组合多种类型操作的场景时非常有用例如图形界面中的事件处理事件类型 × 控件类型。实战示例简单表达式求值假设表达式由数字和操作符组成我们有两个variantValue和Operator。using Value std::variantint, double; using Operator std::variantstd::plus, std::minus, std::multiplies; // 访问者需要处理所有 Value x Operator 的组合 auto apply_operation [](auto val, auto op) - Value { // 我们需要将操作应用到val上。但val可能是int或doubleop可能是plus, minus等。 // 我们可以再次利用visit或者使用if constexpr。 // 这里展示一个技巧使用std::invoke return std::visit([](auto v) - Value { return std::visit([](auto o) - Value { // o是一个函数对象如std::plus。我们需要另一个值这里假设是第二个操作数同类型 // 为了示例我们简单返回 v op v (即 vv, v-v, v*v) // 实际中第二个操作数可能来自另一个variant return o(v, v); // 注意这要求v的类型支持该操作符 }, op); }, val); }; // 但这个例子有点牵强。更典型的例子是二元操作 Value a 10; Value b 2.5; Operator op std::minus(); // 一个处理 (Value, Operator, Value) 的访问者会更复杂但思路是嵌套visit或使用overloaded处理所有组合。处理多个variant时访问者需要是一个可调用对象它能接受N个参数对应N个variant可能类型的笛卡尔积。这通常会导致访问者内部逻辑复杂。在实践中如果组合爆炸可能需要重新设计数据结构或者将部分逻辑下沉到各个类型内部。实操心得对于超过两个variant的多维分发代码复杂度会急剧上升。在实际项目中应仔细评估是否真的需要这种级别的灵活性。很多时候将部分行为内聚到各个类型中即传统的面向对象多态或者使用std::visit只处理一个主要variant其他参数作为通用上下文传入是更可维护的选择。4. 深入原理与性能优化4.1 visit的实现机制与编译器优化理解std::visit的实现有助于写出性能更好的代码。典型实现会使用一个函数指针表vtable-like或跳转表。编译器在编译期知道所有可能的类型组合可以为每一种组合生成特定的调用路径。当代码足够简单时现代编译器如GCC、Clang、MSVC能够进行积极的优化内联优化如果访问者尤其是Lambda的定义在visit调用处可见并且逻辑简单编译器很可能将整个分发逻辑和内联的处理函数优化成一段直接的代码消除函数调用开销。跳转表优化对于基于索引的visit实现编译器可能将其优化为一个高效的跳转表类似switch语句其时间复杂度是O(1)。常量传播如果variant的值或类型在编译期可知例如通过constexpr上下文编译器甚至能在编译期完成计算完全消除运行时开销。为了帮助编译器优化你可以将访问者定义为constexpr如果其逻辑允许。尽量让访问者的逻辑简单并放在头文件中确保调用处可见。对于性能极度关键的循环可以考虑使用std::get_if进行手动的、针对已知少数类型的优化但这会牺牲代码的清晰度和扩展性。在大多数情况下信任编译器的优化能力是更好的选择。4.2 与继承多态的性能对比这是开发者最关心的问题之一。std::visit基于variant的方案称为“静态多态”或“类型安全联合”与传统的基于虚函数的动态多态在性能上有何区别内存布局variant是值语义对象通常存储在栈或直接嵌入其他对象中内存局部性好。而继承多态通常涉及堆分配和指针间接访问缓存不友好。分发机制虚函数通过虚函数表vtable间接调用每次调用有一次指针解引用和跳转。优化良好的visit可能通过跳转表或直接内联实现分发间接层更少或没有。编译期知识visit的所有类型在编译期已知编译器有更大的优化空间。虚函数调用在编译期只知道基类接口具体实现是运行时的。基准测试通常显示对于简单的、非虚拟的操作如一个简单的getter或数学运算variantvisit的方案性能显著优于虚函数调用有时甚至能达到与手写switch语句相当的速度。对于复杂的、本身就有一定计算量的操作两者的差距会缩小但variant方案在内存访问上仍有优势。选择建议当类型的集合是固定的、封闭的不会在运行时动态增加新的派生类并且性能至关重要时优先考虑variantvisit。当类型的集合是开放的、需要运行时动态扩展如插件系统或者对象具有复杂的生命周期和所有权语义时传统的继承多态更合适。两者也可以混合使用例如用variant管理一组具体的、固定的消息类型而每个消息类型内部可能又包含复杂的、使用继承的组件。4.3 异常安全与valueless状态std::variant在一种特殊情况下会进入valueless_by_exception状态当在类型切换赋值或emplace过程中新类型的构造函数抛出异常而旧类型的析构函数也抛出异常时。C异常机制不允许同时处理两个异常此时variant会被置于一个无值的无效状态。struct ThrowingType { ThrowingType() { throw std::runtime_error(ctor failed); } ~ThrowingType() noexcept(false) { throw std::runtime_error(dtor failed); } // 错误示范析构不该抛异常 }; std::variantint, ThrowingType v; try { v.emplace1(); // 尝试构造ThrowingType构造函数抛出异常 } catch (...) { // 此时如果ThrowingType的析构函数在栈回溯过程中也抛出异常 // variant可能变为valueless_by_exception。 if (v.valueless_by_exception()) { std::cout Variant is valueless!\n; } }重要警告析构函数绝对不应该抛出异常这不仅是variant的要求也是C异常安全的基本准则。如果析构函数可能失败应该提供另一个公共函数如close()来执行可能失败的操作并在析构函数中吞下异常或终止程序。在valueless状态下大多数操作如std::getstd::visit都会抛出std::bad_variant_access。因此在编写健壮的代码时尤其是在可能发生异常的场景下检查valueless_by_exception()是一个好习惯。5. 实战项目用variant重构一个简易JSON解析器让我们通过一个稍微复杂的例子将所学知识融会贯通。我们将实现一个简易的JSON节点类型它可以是null、布尔值、数字、字符串、数组或对象并用std::variant来承载。5.1 定义JSON值类型#include variant #include string #include vector #include unordered_map #include memory namespace my_json { struct Null {}; using Value std::variant Null, bool, int, double, std::string, std::vectorValue, std::unordered_mapstd::string, Value ; // 为了方便给这些类型起个别名 using Array std::vectorValue; using Object std::unordered_mapstd::string, Value; }这里我们定义了一个Null空类型而不是使用nullptr_t因为nullptr_t在某些操作如输出上可能不如自定义类型方便。Array和Object是递归定义的这要归功于variant在C17中支持不完整类型在定义Value时Array和Object中的Value类型还在定义中但编译器允许这种递归定义。5.2 实现JSON字符串化访问者我们需要一个访问者来将Value转换成字符串。这里使用重载函数对象的方式结构更清晰。namespace my_json { class StringifyVisitor { public: // 重载调用运算符处理所有类型 std::string operator()(Null) const { return null; } std::string operator()(bool b) const { return b ? true : false; } std::string operator()(int i) const { return std::to_string(i); } std::string operator()(double d) const { // 简单处理实际项目可用更精确的格式化 auto s std::to_string(d); // 去除多余的零 s.erase(s.find_last_not_of(0) 1, std::string::npos); if(s.back() .) s.pop_back(); return s; } std::string operator()(const std::string s) const { return \ escape_string(s) \; } std::string operator()(const Array arr) const { std::string result [; bool first true; for (const auto elem : arr) { if (!first) result , ; first false; result std::visit(*this, elem); // 递归访问 } result ]; return result; } std::string operator()(const Object obj) const { std::string result {; bool first true; for (const auto [key, value] : obj) { if (!first) result , ; first false; result \ escape_string(key) \: ; result std::visit(*this, value); // 递归访问 } result }; return result; } private: static std::string escape_string(const std::string s) { // 简易的转义实际需处理更多控制字符 std::string out; for (char c : s) { switch (c) { case \: out \\\; break; case \\: out \\\\; break; case \b: out \\b; break; case \f: out \\f; break; case \n: out \\n; break; case \r: out \\r; break; case \t: out \\t; break; default: out c; break; } } return out; } }; // 辅助函数 std::string to_string(const Value v) { return std::visit(StringifyVisitor{}, v); } }这个访问者展示了递归处理的能力。在处理Array和Object时它递归地调用std::visit(*this, elem)来处理嵌套的Value。这正是访问者模式强大之处——可以轻松处理递归数据结构。5.3 实现类型安全的访问接口直接使用std::get或std::get_if访问variant成员虽然可以但错误信息不友好。我们可以封装一些辅助函数。namespace my_json { // 安全获取值类型不匹配时抛出带详细信息的异常 templatetypename T T get_as(const Value v) { try { return std::getT(v); } catch (const std::bad_variant_access) { throw std::runtime_error(JSON type mismatch); } } // 检查类型 templatetypename T bool is_type(const Value v) { return std::holds_alternativeT(v); } // 尝试获取返回指针 templatetypename T const T* get_if(const Value* v) { return std::get_ifT(v); } }5.4 使用示例int main() { using namespace my_json; // 构建一个复杂的JSON对象 Value json Object{ {name, Alice}, {age, 30}, {is_student, false}, {scores, Array{95, 88.5, 72}}, {address, Object{ {city, New York}, {zip, 10001} }}, {metadata, Null{}} }; // 转换为字符串 std::cout to_string(json) std::endl; // 安全访问 auto obj get_asObject(json); std::cout Name: get_asstd::string(obj.at(name)) std::endl; // 类型检查与条件访问 if (auto* scores get_ifArray(obj.at(scores))) { std::cout Has scores array with size: scores-size() std::endl; } return 0; }这个简易JSON实现展示了std::variant如何优雅地管理一个封闭的、递归的类型集合。相比于用继承实现一个JsonNode基类variant的方案更值语义内存局部性更好访问性能也更有优势。std::visit让针对不同类型的不同操作如序列化变得集中而清晰。6. 常见陷阱、调试技巧与最佳实践即使掌握了基本用法在实际项目中应用variant和visit时仍会遇到一些坑。下面是我从实战中总结的经验。6.1 陷阱一忘记处理所有类型这是编译错误但信息可能不直观。如果你用重载函数对象或overloaded但没有为variant的某个类型提供对应的operator()重载编译器会报错指出“不可调用”或“没有匹配的函数”。解决方案确保你的访问者能处理所有类型。使用static_assert配合std::variant_size_v可以做一些编译期检查但最实用的方法是依赖编译器的错误信息并仔细核对类型列表。6.2 陷阱二ambiguous overload重载歧义当variant中的类型存在转换关系如int和long或派生类与基类或者你的访问者重载了多个可以匹配的类型时可能会产生歧义。std::variantint, long v 42; std::visit([](auto x) { /* ... */ }, v); // 没问题泛型lambda std::visit([](int x) { /* ... */ }, v); // 错误不能匹配long std::visit([](long x) { /* ... */ }, v); // 错误不能匹配int // 需要提供int和long两个重载或者使用泛型lambda。解决方案对于有转换关系的类型考虑使用更精确的类型特征std::is_same_v在泛型Lambda中区分或者确保提供所有类型的明确重载。避免在variant中放入有隐式转换关系的类型除非你明确知道如何处理。6.3 陷阱三递归variant与内存管理就像我们的JSON例子variant可以是递归的包含自身类型的容器。这很强大但要注意深度递归极端情况下可能导致栈溢出如在序列化一个非常深的JSON时。对于生产环境可能需要迭代算法或显式控制递归深度。循环引用Object中某个Value又引用了整个Object会导致无限递归或内存泄漏。这在自定义数据结构中需要特别注意可能需要引入std::shared_ptr来打破值语义的循环或者使用弱引用。6.4 调试技巧打印当前类型在调试时经常需要知道variant当前存的是什么。可以写一个通用的调试访问者auto debug_printer [](const auto arg) { using T std::decay_tdecltype(arg); std::cout typeid(T).name() : arg std::endl; }; std::visit(debug_printer, my_variant);注意typeid(T).name()返回的类型名可能被修饰在GCC/Clang下可以配合cxxabi.h中的__cxa_demangle来获得可读的名称。使用GDB/LLDB现代调试器对std::variant支持良好。在GDB中你可以直接p my_variant它会显示当前存储的索引和值。对于复杂类型可能需要打开模板展开。6.5 最佳实践总结优先选择variant用于封闭类型集合如果你的类型列表在编译期是固定的、有限的variant是比继承更好的选择。使用std::visit代替手写switch这是使用variant的核心模式它更安全、更易于扩展。为常用操作定义访问者类像我们的StringifyVisitor将相关操作封装在一起提高代码可读性和复用性。考虑使用std::overloaded模式它能让创建一组Lambda重载变得非常简洁是社区公认的最佳实践之一。注意异常安全确保析构函数不抛出异常并在关键代码处检查valueless_by_exception()。性能敏感处信任编译器但需实测虽然visit性能通常很好但在最关键的循环中如果性能分析表明它是瓶颈可以考虑使用std::get_if进行手动优化但这应该是最后的手段。结合std::monostate作为可空状态std::variant必须持有一种类型的值。如果你需要一个“空”或“未初始化”的状态可以将std::monostate一个空类加入类型列表作为第一个类型。std::monostate常用于表示“无值”状态并且可以与其他类型进行相等比较。7. 超越基础C20/23中variant的增强C标准仍在演进variant和相关工具也在不断完善。C20的std::visit格式化输出C20的format库可以与visit很好地结合但需要为variant的每种类型提供formatter特化。这稍微有点繁琐但能实现类型安全的格式化输出。C20的using enum和访问者using enum可以简化访问者中对于枚举类型的判断但和variant的直接关联不大。C23的std::variant的期待特性社区一直在讨论为variant加入and_then、transform等Monadic操作类似于std::optional这将使链式操作更便捷。虽然C23最终可能未包含但这是一个重要的设计方向你可以通过自己编写工具函数来模拟。例如一个简单的transform实现思路template typename Variant, typename Visitor auto variant_transform(Variant v, Visitor vis) { return std::visit([](auto arg) - decltype(auto) { // 对arg应用vis但需要处理vis返回不同类型的情况 // 这通常要求vis对所有类型返回相同的类型或者返回一个variant return std::invoke(std::forwardVisitor(vis), std::forwarddecltype(arg)(arg)); }, std::forwardVariant(v)); }这个函数将访问者的返回值包装起来但如果访问者对不同类型的返回值不同那么variant_transform的返回类型将很难确定。这正体现了Monadic操作的复杂性也是未来标准库可能提供更完善支持的地方。掌握std::variant和std::visit意味着你掌握了现代C中处理类型安全、高效多态数据的一把利器。它不仅能让你写出更简洁、更安全的代码更能促使你以新的思维方式来设计程序的数据结构。从今天开始尝试在下一个项目中用variant替换掉那些冗长的switch语句你会立刻感受到代码清晰度的提升。

C++17 std::variant与std::visit实战：告别臃肿条件判断，实现高效类型安全多态

相关推荐

多层神经网络

Pydantic数据契约实战：构建可靠数据流水线的校验体系

AI建筑设计实战：Claude在建筑领域的应用边界与技巧

更多资讯

实测70款ChatGPT插件：真正值得留下的只有这13个

Lithe-IDEA：Spring Boot 开发者的 IntelliJ 轻量优化方案

零成本搭建专业RAW后期工作流：darktable从导入到导出完整教程

Iris数据集与Redis缓存实战：从序列化到分布式锁的完整指南

Jira工作流配置实战：从流程建模到持续进化

Yolo 小白入门 70：封装 FastAPI 推理接口——从 best.pt 到可调用服务

今日更新

AI驱动的自动化专利分析平台技术解析

LeetCode-Go 题解：1252. Cells with Odd Values in a Matrix（奇数值单元格计数）双解法剖析

在线答疑系统Java毕设实战：Spring Boot前后端分离与状态流转

本周精选

AI驱动的自动化专利分析平台技术解析

LeetCode-Go 题解：1252. Cells with Odd Values in a Matrix（奇数值单元格计数）双解法剖析

在线答疑系统Java毕设实战：Spring Boot前后端分离与状态流转

本月热门

基于YOLO的焊缝缺陷检测：从数据标注到工业部署全流程实践

分布式服务的决策记录

创业产品的首版范围

读完文章，想聊聊您的网站？