抽象工厂模式 rust和java的实现

C++实时数据流处理在医疗系统中的应用与实战策略 实时数据流处理是现代数据处理架构中的核心技术,它涉及对连续产生的数据序列进行即时采集、处理和分析。其核心原理在于构建低延迟、高吞吐的数据流水线,通过窗口化计算、流式聚合等技术实现数据的实时洞察。这项技术的价值在于能够为业务决策提供即时反馈,在监控、风控、物联网等场景中至关重要。在医疗健康领域,实时数据流处理的应用尤为关键,例如对患者生命体征进行持续监控以实现异常预警。本文聚焦于利用C++实现高可靠医疗实时数据流处理系统,深入探讨了在硬实时与软实时场景下的架构设计、内存管理及并发模型等实战策略,以满足医疗行业 阅读详情

抽象工厂模式

抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。

在抽象工厂模式中,接口是负责创建一个相关对象的工厂,不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

抽象工厂模式提供了一种创建一系列相关或相互依赖对象的接口,而无需指定具体实现类。通过使用抽象工厂模式,可以将客户端与具体产品的创建过程解耦,使得客户端可以通过工厂接口来创建一族产品。

介绍

意图:提供一个创建一系列相关或相互依赖对象的接口,而无需指定它们具体的类。

主要解决:主要解决接口选择的问题。

何时使用:系统的产品有多于一个的产品族,而系统只消费其中某一族的产品。

如何解决:在一个产品族里面,定义多个产品。

关键代码:在一个工厂里聚合多个同类产品。

应用实例:工作了,为了参加一些聚会,肯定有两套或多套衣服吧,比如说有商务装(成套,一系列具体产品)、时尚装(成套,一系列具体产品),甚至对于一个家庭来说,可能有商务女装、商务男装、时尚女装、时尚男装,这些也都是成套的,即一系列具体产品。假设一种情况(现实中是不存在的,但有利于说明抽象工厂模式),在您的家中,某一个衣柜(具体工厂)只能存放某一种这样的衣服(成套,一系列具体产品),每次拿这种成套的衣服时也自然要从这个衣柜中取出了。用 OOP 的思想去理解,所有的衣柜(具体工厂)都是衣柜类的(抽象工厂)某一个,而每一件成套的衣服又包括具体的上衣(某一具体产品),裤子(某一具体产品),这些具体的上衣其实也都是上衣(抽象产品),具体的裤子也都是裤子(另一个抽象产品)。

优点:当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。

缺点:产品族扩展非常困难,要增加一个系列的某一产品,既要在抽象的 Creator 里加代码,又要在具体的里面加代码。

使用场景: 1、皮肤系统,一整套一起换。

抽象工厂模式包含以下几个核心角色:

抽象工厂(Abstract Factory):声明了一组用于创建产品对象的方法,每个方法对应一种产品类型。抽象工厂可以是接口或抽象类。
具体工厂(Concrete Factory):实现了抽象工厂接口,负责创建具体产品对象的实例。
抽象产品(Abstract Product):定义了一组产品对象的共同接口或抽象类,描述了产品对象的公共方法。
具体产品(Concrete Product):实现了抽象产品接口,定义了具体产品的特定行为和属性。
抽象工厂模式通常涉及一族相关的产品,每个具体工厂类负责创建该族中的具体产品。客户端通过使用抽象工厂接口来创建产品对象,而不需要直接使用具体产品的实现类。

实现架构图

我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类 ShapeFactory 和 ColorFactory,这两个工厂类都是扩展了 AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer。

AbstractFactoryPatternDemo 类使用 FactoryProducer 来获取 AbstractFactory 对象。它将向 AbstractFactory 传递形状信息 Shape(CIRCLE / RECTANGLE / SQUARE),以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color(RED / GREEN / BLUE),以便获取它所需对象的类型。

抽象工厂模式的 UML 图

java实现

步骤 1
为形状创建一个接口。

Shape.java
public interface Shape {
   void draw();
}

请添加图片描述

步骤 2
创建实现接口的实体类。

Rectangle.java

Rectangle.java
public class Rectangle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Rectangle::draw() method.");
   }
}
Square.java
public class Square implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Square::draw() method.");
   }
}
Circle.java
public class Circle implements Shape {
 
   @Override
   public void draw() {
      System.out.println("Inside Circle::draw() method.");
   }
}

步骤 3
为颜色创建一个接口。

Color.java
public interface Color {
   void fill();
}

步骤4
创建实现接口的实体类。

Red.java
public class Red implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Red::fill() method.");
   }
}
Green.java
public class Green implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Green::fill() method.");
   }
}
Blue.java
public class Blue implements Color {
 
   @Override
   public void fill() {
      System.out.println("Inside Blue::fill() method.");
   }
}

步骤 5
为 Color 和 Shape 对象创建抽象类来获取工厂。

AbstractFactory.java
public abstract class AbstractFactory {
   public abstract Color getColor(String color);
   public abstract Shape getShape(String shape);
}

步骤 6
创建扩展了 AbstractFactory 的工厂类,基于给定的信息生成实体类的对象。


ShapeFactory.java
public class ShapeFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      if(shapeType == null){
         return null;
      }        
      if(shapeType.equalsIgnoreCase("CIRCLE")){
         return new Circle();
      } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
         return new Rectangle();
      } else if(shapeType.equalsIgnoreCase("SQUARE")){
         return new Square();
      }
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      return null;
   }
}
ColorFactory.java
public class ColorFactory extends AbstractFactory {
    
   @Override
   public Shape getShape(String shapeType){
      return null;
   }
   
   @Override
   public Color getColor(String color) {
      if(color == null){
         return null;
      }        
      if(color.equalsIgnoreCase("RED")){
         return new Red();
      } else if(color.equalsIgnoreCase("GREEN")){
         return new Green();
      } else if(color.equalsIgnoreCase("BLUE")){
         return new Blue();
      }
      return null;
   }
}

步骤 7
创建一个工厂创造器/生成器类,通过传递形状或颜色信息来获取工厂。

FactoryProducer.java
public class FactoryProducer {
   public static AbstractFactory getFactory(String choice){
      if(choice.equalsIgnoreCase("SHAPE")){
         return new ShapeFactory();
      } else if(choice.equalsIgnoreCase("COLOR")){
         return new ColorFactory();
      }
      return null;
   }
}

步骤 8
使用 FactoryProducer 来获取 AbstractFactory,通过传递类型信息来获取实体类的对象。

AbstractFactoryPatternDemo.java
public class AbstractFactoryPatternDemo {
   public static void main(String[] args) {
 
      //获取形状工厂
      AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
 
      //获取形状为 Circle 的对象
      Shape shape1 = shapeFactory.getShape("CIRCLE");
 
      //调用 Circle 的 draw 方法
      shape1.draw();
 
      //获取形状为 Rectangle 的对象
      Shape shape2 = shapeFactory.getShape("RECTANGLE");
 
      //调用 Rectangle 的 draw 方法
      shape2.draw();
      
      //获取形状为 Square 的对象
      Shape shape3 = shapeFactory.getShape("SQUARE");
 
      //调用 Square 的 draw 方法
      shape3.draw();
 
      //获取颜色工厂
      AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
 
      //获取颜色为 Red 的对象
      Color color1 = colorFactory.getColor("RED");
 
      //调用 Red 的 fill 方法
      color1.fill();
 
      //获取颜色为 Green 的对象
      Color color2 = colorFactory.getColor("GREEN");
 
      //调用 Green 的 fill 方法
      color2.fill();
 
      //获取颜色为 Blue 的对象
      Color color3 = colorFactory.getColor("BLUE");
 
      //调用 Blue 的 fill 方法
      color3.fill();
   }
}

步骤 9
执行程序,输出结果:

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.

rust实现

由于设计思想是一致的,关于rust的实现就不再赘述上述的步骤,直接贴上完整的代码。

// 定义接口

// 创建实体类
struct Rectangle;
struct Square;
struct  Circle;
struct ShapeFactory ;
struct ColorFactory ;
struct  FactoryProducer ;
struct Red;
struct Blue;
struct  Green;
pub trait Color{
    fn fill(&self);  
}
impl Color for Red {
    fn fill(&self) {
        println!("Inside Red::fill() method.");
    }
}
impl Color for Blue {
    fn fill(&self) {
        println!("Inside Blue::fill() method.");
    }
}
impl Color for Green {
    fn fill(&self) {
        println!("Inside Green::fill() method.");
    }
}


pub  trait Shape {
    fn draw(&self);  
}
impl Shape for Rectangle {
    fn draw(&self) {
        println!("Inside Rectangle::draw() method.");
    }
}
impl Shape for Square {
    fn draw(&self) {
        println!("Inside Square::draw() method.");
    }
}
impl Shape for Circle {
    fn draw(&self) {
        println!("Inside Circle::draw() method.");
    }
}
pub trait AbstractFactory {
    fn get_color(&self,color: &str)->Result<Box<dyn Color>>;
    fn get_shape(&self,shape: &str)->Box<dyn Shape>;
 }

impl AbstractFactory for ShapeFactory {
    fn get_shape(&self,shape_type: &str)->Box<dyn Shape>{
        if shape_type=="CIRCLE" {
            Box::new(Circle{})
        }else if shape_type=="RECTANGLE" {
            Box::new(Rectangle{})
        }else if  shape_type=="SQUARE"{
            Box::new(Square{})
        }else {
            panic!("输入的类型不存在");
        }
  
    }
    fn get_color(&self,_shape_type: &str)->Box<dyn Color>{

        panic!("输入的类型不存在");
  
    }
}
impl AbstractFactory for ColorFactory {
    fn get_color(&self,shape_type: &str)->Box<dyn Color>{
        if shape_type=="RED" {
            Box::new(Red{})
        }else if shape_type=="BLUE" {
            Box::new(Blue{})
        }else if  shape_type=="GREEN"{
            Box::new(Green{})
        }else {
            panic!("输入的类型不存在");
        }
    }
    fn get_shape(&self,_shape_type: &str)->Box<dyn Shape>{

        panic!("输入的类型不存在");
    }

}

impl  FactoryProducer {
    fn get_factory(choice: &str)-> Box<dyn AbstractFactory>{
        if choice=="COLOR" {
            Box::new(ColorFactory{})
        }else if choice=="SHAPE" {
            Box::new(ShapeFactory{})
        }else {
            panic!("输入的类型不存在");
        }
    }
}

fn main() {
    let shape=FactoryProducer::get_factory("SHAPE");
    let shape1=shape.get_shape("CIRCLE");
    shape1.draw();
    let shape2=shape.get_shape("RECTANGLE");
    shape2.draw();
    let shape3=shape.get_shape("SQUARE");
    shape3.draw();
    let color=FactoryProducer::get_factory("COLOR");
    let color1=color.get_color("RED");
    color1.fill();
    let color2=color.get_color("BLUE");
    color2.fill();
    let color3=color.get_color("GREEN");
    color3.fill();
}

rust代码仓库

https://github.com/onenewcode/design.git
本教程项目在bin文件夹下的abstractfactory.rs文件中

Qdrant 深度拆解:35K Star 的 Rust 向量数据库,是如何把 HNSW、Payload 过滤和量化压缩揉成一台机器 Qdrant 是基于 Rust 构建的向量数据库,以高效协同稠密向量(HNSW)、Payload 过滤与量化索引著称。其核心优势在于三者在查询中同步生效,兼顾召回率与性能。适用于 RAG、语义搜索、推荐系统及多租户场景,但不擅长事务或精确检索。架构分层清晰,写入经 WAL 保障一致性,检索通过分片与段并行加速。关键技术包括过滤感知 HNSW、ACORN 跨跳搜索、八类 Payload 索引、四档量化(如 TurboQuant、Product)及灵活多租户策略。最新版本 v1.20.1 强化了嵌套索引与重打分 阅读详情

相关推荐

电磁阀的符号解读

先数方框数量定“几位”(工作位置数 );数接口数量(P、A、R等 )定“几通”;看箭头、截断符号,结合常态位(弹簧侧/中间位 ),分析通电/断电时的通路切换;字母(P、A、R )、线圈(单/双电控 )、弹簧(复位 )辅助确认功能(如NO/NC对应常态通断 )。不同厂家符号细节(如编码、线圈画法 )有差异,遇到陌生符号,建议结合产品手册、品牌规范核对,就能精准读懂电磁阀的“语言”啦~

创新改变世界! 6910

抽象工厂模式:跨平台UI与游戏开发的终极解决方案

抽象工厂模式是创建型设计模式的核心成员,通过定义产品家族的创建接口实现系统与具体实现的解耦。其核心原理是封装一组相关对象的创建过程,使客户端无需关心具体类即可获得风格一致的产品组合。在工程实践中,该模式特别适合需要保证产品兼容性的场景,比如跨平台UI开发中不同操作系统风格的控件组,或是游戏开发中需要统一切换的整套美术资源。通过Java/Kotlin等语言的接口特性,开发者可以优雅地实现多套产品线的动态切换。结合依赖注入和单例等技巧,还能进一步优化工厂的创建性能和管理效率。现代前端框架和游戏引擎普遍采用类似思

weixin_33600816的博客 230

Unity 实现动态网格地图生成与交互组件

本文详细介绍了在Unity中实现动态网格地图生成与交互组件的完整方案。从基础网格单元实现到高级交互功能,涵盖网格生成器核心逻辑、事件驱动架构、性能优化技巧以及六边形网格等特殊实现。特别适合游戏开发者学习如何构建战棋、模拟经营类游戏的可交互地图系统,提升开发效率与用户体验。

weixin_29015483的博客 1073

go不应该用JAVA设计模式_go 和 rust 设计模式对比 - 工厂模式 | 水木双

定义工厂模式可分为三类:简单工厂模式工厂方法模式抽象工厂模式简单工厂模式属于创建型模式,不属于 23 种 GOF 设计模式之一,由一个工厂对象决定创建出哪一种产品类实例,逻辑为定义一个工厂类,根据传入的参数不同返回不同的产品实例,被创建的实例具有共同的父类或接口。工厂方法模式跟简单工厂模式的区别就是,定义了一些工厂子类,每个工厂子类都可以创建相对应的产品类实例,而不用工厂父类去根据参数创建,一般在...

weixin_42612405的博客 184

IBM V3700更换控制器2(503错误)

正常的node1 ,机器代码版本:7.5.0.3, 机器代码构建:115.51.1509171734000。耐心等待后,刷新,看到node2,状态变成 节点状态:服务,错误:656,版本和node1一样了。新换的node2 ,机器代码版本:7.2.0.5, 机器代码构建:87.8.1404221000。耐心等待,刷新,node2,状态看到了,节点状态:活动,错误 724 1 1 0。拔出故障的控制,把内存和HBA卡,电池换到新的控制器。新的控制还是报错无法使用,节点状态:服务 错误:503。

klyshao的博客 4450

Android 12.0 framework系统修改安兔兔等显示的屏幕尺寸大小功能实现

在12.0的系统rom定制化开发中,在使用第三方app检测系统的一些信息中,比如安兔兔 设备信息等检测app中,有时候显示的屏幕尺寸大小和 产品规格书等信息不同,稍微有些差异,所以就需要看下系统framework层中,相关的设备信息是怎么读出来的,然后做些调整 接下来就来分析相关功能

安卓兼职framework和app工程师的博客 478

深度解析:如何通过MAA开源自动化助手实现《明日方舟》全日常一键管理

MAA Assistant Arknights(简称MAA)是一款专为《明日方舟》玩家设计的开源自动化工具,基于先进的图像识别技术和智能决策系统,帮助玩家实现全日常任务的一键自动化管理。作为一款完全开源的项目,MAA不仅大幅提升游戏效率,更通过模块化架构和多语言支持为开发者提供了丰富的二次开发可能性。 ## 项目定位解析:从游戏助手到开源技术平台 MAA的定位远超传统游戏辅助工具,它构建了一个

gitblog_00871的博客 146

128、点云配准与ICP:经典配准算法与深度学习配准

上周调试一台双臂协作机器人,左手持结构光相机扫描桌面上的随机堆叠工件,右手准备执行抓取。问题出在“对齐”这一步——相机扫描得到的点云和CAD模型点云之间差了大约15度的旋转,导致抓取姿态计算出来直接怼到桌面上。我第一反应是“ICP跑一下不就行了”,结果跑了三分钟,误差纹丝不动,甚至越迭代越发散。后来查了日志才发现,初始位姿给得太离谱,ICP直接掉进了局部最优。这个场景太典型了——很多人以为点云配准就是调个ICP库函数,实际工程里坑比想象中多得多。今天这篇笔记,咱们把点云配准这件事从头捋一遍。

sundong_81的博客 49

深度解析:MAA明日方舟自动化助手的技术架构与实现原理

MAA明日方舟自动化助手作为一款基于图像识别技术的游戏辅助工具,其技术实现体现了现代自动化系统的典型架构。本文将从技术层、应用层和生态层三个维度,深入解析这一开源项目的技术原理、实现机制和扩展能力,为技术爱好者和开发者提供全面的技术视角。 ## 图像识别引擎:自动化决策的核心基础 MAA的核心技术基础建立在计算机视觉和图像识别之上。系统通过实时截取游戏画面,运用多种图像处理算法进行分析和决策,

gitblog_00138的博客 89

多模态轨迹预测:行人、车辆的交互式推理

多模态轨迹预测:行人、车辆的交互式推理 ,人工智能,计算机视觉,大模型,AI,本文围绕多模态轨迹预测中行人与车辆的交互式推理展开,介绍了其定义,即综合多种信息预测交通参与者未来多种轨迹。涵盖基础概念如轨迹表示、模态、交互关系,技术框架包括数据处理、特征提取、预测模型(物理、机器学习、深度学习模型等)及结果评估。还探讨了交互式推理方法、面临的不确定性处理等挑战、应用场景、未来发展方向、相关工具及实际案例,展现了该技术在智能交通等领域的重要性与发展潜力。​

不踩坑,不知道坑有多深;不总结,踩过的坑白踩。 14万+

【0000】PostgreSQL V17.4 内核源码剖析专栏(2017 ~ 2025.11.28 更新)

本专栏将会持续更新,直到将PostgreSQL V13.2源码涉及的所有原理、技术剖析完成为止。每一篇文章都是经过多次的源码阅读 + 调试,得以验证之后才梳理成文章形式。最终该专栏的文章数量应该在一万篇或以下,这也是文章序号从【0000】开始的缘故。通过本专栏的学习,能够让你掌握PostgreSQL数据库中的每个技术背后,底层的实现原理。

Postgres 数据库内核开发工程师 1万+

设计模式-建造者模式(Builder Pattern)

建造者模式 定义 将一个复杂对象的构建与它的表示分离,使得同样的构建过程可以创建不同的表示。 创建者模式隐藏了复杂对象的创建过程,它把复杂对象的创建过程加以抽象,通过子类继承或者重载的方式,动态的创建具有复合属性的对象。 类型 创建型。 适用场景 需要生成的产品对象有复杂的内部结构,这些产品对象具备共性。 隔离复杂对象的创建和使用,并使得相同的构建过程可以创建不同的产品。 建造者模式与抽象工厂...

kaven 4811

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

Qwen3.6-Max三大核心突破:长上下文、AST感知与工具直连

大语言模型的代码生成与工程落地能力,正从‘文本续写’迈向‘上下文原生理解’。其底层依赖长上下文建模、代码结构感知(如AST嵌入)和外部系统协同推理三大技术支柱。Qwen3.6-Max通过动态稀疏注意力掩码(DSAM)提升语义召回率,首次将AST节点类型硬编码至词元表示,实现函数签名、错误边界等约束的自动推演;同时以工具感知层替代传统function calling,使数据库、监控、工单系统成为模型的‘感觉器官’。这些能力共同支撑AI原生开发、智能IDE插件、SRE辅助诊断等高价值场景,标志着开发者工作流从‘

蓝色妖姬 636

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

VB摄像头监控

该VB模块可对摄像头捕获的画面进行录像等,可在创建的窗口进行控制

Serverless架构内存管理与高并发优化实践

Serverless架构通过事件驱动和自动扩展机制,实现了计算资源的精细化管理和按需分配。其核心原理是将应用拆分为无状态函数,由云平台动态调度执行。这种架构特别适合处理突发流量和间歇性工作负载,能显著降低运维复杂度。在Vercel等Serverless平台上,内存管理成为关键优化点,开发者需要采用流式处理、依赖优化等技术控制内存消耗。同时,通过预热策略、连接池管理等手段可以有效应对高并发场景,确保服务稳定性和响应速度。本文以图像处理服务为例,详细解析Serverless环境下的性能调优方法和实战经验。

weixin_34226706的博客 320

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

14、设计模式应用举例:抽象工厂模式:存款凭证

本文基于抽象工厂模式设计银行存款凭证系统,通过定义抽象产品(存款单、公章)与具体实现,为不同银行(中国银行、建设银行、交通银行)提供定制化凭证。各银行类实现抽象工厂方法,生成对应存款单与具有独特形状和名称的公章图像。应用程序通过统一接口创建不同银行的凭证,实现产品族的协同生成,体现了抽象工厂模式在解耦与扩展性方面的优势。

博风_刺耳的博客(网络记事本) 155

rust: Fan-out/Fan-in Pattern

本项目基于Rust实现珠宝行业全流程的扇出/扇入模式,采用DDD六层架构。通过ProcessRequestDto与ProcessResponseDto传输数据,将采购、设计、生产等12个业务阶段抽象为可并行执行的FanoutTask子任务。核心由JewelryFanoutFanin实现并行调度:先扇出至12个线程并发执行,再统一扇入汇总结果。系统集成日志(文件+控制台)、重试熔断、内存仓储及依赖注入容器,支持顺序与并发两种调度方式,确保高并发下任务可靠执行与可观测性。

Geovin Du Dream Park 158

组网第63课:安全域划分——Trust/Untrust/DMZ、区域模型、与 VLAN 的关系

一组接口 + 一组策略 + 一条默认拒绝。一组接口:这个域包含哪些物理口、VLAN、子接口;一组策略:这个域到别的域放行什么、拒绝什么;一条默认拒绝:没写进策略的,一律不通。第三条最关键。没有默认拒绝,前面划的域全是装饰。

qq_36765170的博客 569

Rust组织管理(AI回答)

你想做的事JS / Python 做法Rust 做法把一个文件纳入工程新建文件即可新建 xxx.rs 后,必须在入口写mod xxx;挂载对外暴露函数/结构体export(Python 默认全公开)默认全私有,必须显式加pub引入别处的函数use crate::模块名::函数名;找路径的基准词./ 或 ../(从 src 根出发)、(上一级 ../)、(当前级 ./)日常写项目:不要用 #[path],直接遵守默认规则——

yaoct的博客 153

自建 RustDesk 服务端后,做一个“装完就能连“的客户端

目前市面上的远程工具(如向日葵、toDesk等)免费版基本上都卡的不行,而且收费版好像也会卡。如果有云服务的话,可以基于 RustDesk 的 hbbs / hbbr 自己部署一套,不过会碰到一个问题:每台电脑装完客户端,都得手动去设置里填三样东西——ID 服务器、中继服务器、Key。填错一个就连不上,还得远程指导同事操作。这篇记录两种解决办法,以及云端编译的完整流程。内容基于 RustDesk 1.5.3 的源码。

风声的专栏 605

Rust LeetCode443 算法题解

LeetCode 443 字符串压缩:原地行程编码,用 start 标记组起点、next 扫描组边界、i 原地写出;长度 1 不写计数使编码不膨胀,写指针不越过读指针。时间 O(n),额外空间 O(1)。

weixin_43379230的博客 103

GitHub 热榜项目:日榜(2026-11-10)

本期共 11 个热门开源项目,合计新增 13,136 stars。榜单前三分别是 Anthropic 的 Agent Skills 仓库、Meta 开源的 React 设计系统 Astryx(+3,278)和用户名检索工具 sherlock(+4,267,本期涨星最多)。其余项目覆盖 DeepMind 的物理引擎 MuJoCo、Claude 官方示例集、自托管智能体记忆系统 GBrain、用 Rust 写的浏览器自动化 CLI、基于 WiFi 信号的人体感知平台 RuView、多市场股票分析工具,以及 Ho

u130130的博客 441

GitHub 今日推荐|HGhubX:Tauri 2 跨平台短剧客户端实战

Tauri 2 + Rust + React 构建的跨平台短剧观看客户端,实现 HLS 代理、AES 封面解密、多线路探测与会话隔离,覆盖桌面与移动全平台。

wfly blog 312

Rust 日志追踪实战:工业边缘场景下的 tracing

Rust 生态下:相比println!log,它提供结构化字段、span 上下文、异步友好和 OpenTelemetry 集成。本文从工程实战角度梳理 tracing 的用法与常见的坑。

ZenovaEdgeOS的博客 558

ARTCRAFT系列软件简单试用手记1

AI辅助开发推动开源重构热潮,ARTCRAFT系列以Rust重写经典软件,性能媲美C/C++。其Launcher支持多平台、多架构,可快速部署开源版Excel(GridCraft)与Word(WordCraft),启动速度远超Office 2016。界面类Office 2016,但暂不完善汉字字号与红头嵌套编辑。项目持续更新,主打“CraftAnything”理念——理解软件原理,自创版本,未来可期。

olegja3d的博客 208

第 1 讲:内存布局与所有权解剖——栈帧、胖指针与“移动/拷贝”在汇编层面的真实面目

看图最下面的(或者数组切片&[T]它在栈上占16 个字节,由(ptr, len)两个机器字组成。这就是系统编程里常说的胖指针(普通指针只有 8 字节地址,它胖了一倍,多带了一个 8 字节的长度或虚表指针)。痛点追问:C 语言里表示字符串切片只要一个 8 字节的char*,为什么 Rust 非要浪费双倍的栈空间搞成 16 字节?如果少掉len这一环会出什么乱子?回想一下 C 语言是怎么知道一个字符串在哪结束的:靠在内存末尾塞一个字节的\0求长度是 $O(N)$ 的苦力活:在 C 里调strlen(p)

yaoct的博客 167
上一篇: Gradle笔记 二 Gradle的基础Groovy
下一篇: redis笔记 三 redis持久化
过去日记
过去日记 新星创作者: 后端开发技术领域 新星创作者: 后端开发技术领域
博客等级 码龄3年 5343粉丝 225原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

过去日记

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值