RUST 编程语言 绘制随机颜色图片 画圆形 画矩形 画直线

什么是Rust

Rust是一种系统编程语言，旨在提供高性能和安全性。它是由Mozilla和其开发社区创建的开源语言，设计目标是在C++的应用场景中提供一种现代、可靠和高效的选择。Rust的目标是成为一种通用编程语言，能够处理各种计算任务，包括网络编程、并发编程、系统编程、WebAssembly等。

Rust的特点

1. 内存安全和高性能：Rust语言设计时优先考虑了内存安全和高性能。通过其独特的所有权系统和借用检查器，Rust可以确保在编译时捕获所有可能的内存错误，如悬挂指针和双重释放。这使得Rust能够在保持内存安全的同时，提供接近C++的性能。

2. 并发和多线程：Rust提供了一套强大的并发原语，使得编写并行和并发代码变得容易而安全。通过其所有权系统和生命周期系统，Rust可以防止数据竞争和其他并发问题，使得多线程编程更加可靠。

3. 编译型语言：Rust是一种编译型语言，这意味着它需要在编译时检查所有的类型错误和内存问题。这有助于在代码运行之前捕获潜在的错误，从而提高代码的可靠性。

4. 强大的社区支持：Rust拥有一个庞大而活跃的社区，为开发者提供了大量的资源和支持。无论是初学者还是经验丰富的开发者，都可以在社区中找到他们需要的资源和帮助。

5. 广泛的应用场景：Rust适用于各种应用场景，包括网络编程、并发编程、系统编程、WebAssembly等。此外，由于其优异的性能和安全性，Rust也被用于开发一些关键的基础设施项目。

Rust与其他语言的对比优势

1. 与C++相比：尽管C++是一种强大的系统编程语言，但它存在一些内存安全问题，如悬挂指针和双重释放。而Rust通过其所有权系统和借用检查器，可以避免这些内存错误，提供更高的安全性。此外，Rust的性能也非常接近C++，可以作为其可靠和高效的替代选择。

2. 与Go相比：Go是一种现代的并发编程语言，具有简洁的语法和强大的并发原语。然而，Go的并发模型是基于协程的，这使得编写复杂的并发代码变得困难。相比之下，Rust的并发模型更加灵活和强大，可以更好地处理并发问题。

3. 与Python/ target=_blank class=infotextkey>Python相比：Python是一种高级的动态类型语言，易于学习和使用。然而，Python的性能相对较低，且存在一些内存安全问题。对于需要高性能和安全性的应用场景，Rust可以作为一种更好的选择。

4. 与JAVA相比：Java是一种静态类型、面向对象的编程语言，具有强大的并发框架和卓越的性能。然而，Java在内存管理方面存在一些限制，如垃圾回收的停顿时间和对象分配的性能问题。相比之下，Rust提供了更好的内存安全性和性能，可以作为一种更好的选择。

总之，Rust是一种强大、安全和高性能的系统编程语言。通过其独特的所有权系统和并发模型，Rust为开发者提供了一种可靠和高效的解决方案，适用于各种应用场景。与C++、Go、Python和Java等其他语言相比，Rust在内存安全、性能和并发处理方面具有显著的优势。

首先，程序创建了一个事件循环event_loop和一个窗口window。

接着，程序创建了一个图形上下文context和一个绘制表面surface。

在事件循环中，程序通过匹配event来处理不同的事件。

当窗口需要重绘时，程序首先获取窗口的尺寸，并调整绘制表面的尺寸。

然后，程序使用一个循环来填充随机颜色到绘制表面的缓冲区中。

接下来，程序绘制一条直线，将其颜色设置为白色。

程序还绘制了一个圆形和一个矩形，并根据距离圆心或矩形边界的距离设置颜色。

最后，程序将缓冲区呈现到绘制表面。

这段代码是一个简单的图形绘制程序，它展示了如何使用Rust和相关库来创建图形界面应用程序。

需要新在工程目录 Cargo.toml 添加如下代码，配置工程和添加库

[package]
name = "test_draw"
version = "0.1.0"
edition = "2021"

[dependencies]
softbuffer = "0.4.0"
winit = "0.29.7"

主要程序main.rs

use std::num::NonZeroU32;
use std::rc::Rc;
use winit::event::{Event, WindowEvent};
use winit::event_loop::{ControlFlow, EventLoop};
use winit::window::WindowBuilder;
// 主函数，程序的入口点
fn main() {
    // 初始化事件循环
    let event_loop = EventLoop::new().unwrap();
    // 创建窗口
    let window = Rc::new(WindowBuilder::new().build(&event_loop).unwrap());
    // 创建图形上下文
    let context = softbuffer::Context::new(window.clone()).unwrap();
    // 创建绘图表面
    let mut surface = softbuffer::Surface::new(&context, window.clone()).unwrap();

    // 运行事件循环
    event_loop.run(move |event, elwt| {
        // 设置事件循环的控制流为等待状态
        elwt.set_control_flow(ControlFlow::Wait);

        // 处理发生的事件
        match event {
            // 当窗口需要重绘时
            Event::WindowEvent { window_id, event: WindowEvent::RedrawRequested } if window_id == window.id() => {
                // 获取窗口的尺寸
                let (width, height) = {
                    let size = window.inner_size();
                    (size.width, size.height)
                };
                // 调整绘图表面的尺寸
                surface
                    .resize(
                        NonZeroU32::new(width).unwrap(),
                        NonZeroU32::new(height).unwrap(),
                    )
                    .unwrap();
                
                // 随机填充颜色
                // 填充随机颜色

                let mut buffer = surface.buffer_mut().unwrap();
                for index in 0..(width * height/2) {
                    let y = index / width;
                    let x = index % width;
                    let red = x % 255;
                    let green = y % 255;
                    let blue = (x * y) % 255;

                    buffer[index as usize] = blue | (green << 8) | (red << 16);
                }

                // 绘制直线
                // 划线

                for index in (width * height/2)..(width * height/2+width*5) {
                   
                    let red = 169;
                    let green = 123;
                    let blue = 62;
                    if index <= (width * height/2+width*5){
                        buffer[index as usize] = 0 | (255 << 8) | (0 << 16);
                    }
                    else{
                        buffer[index as usize] = blue | (green << 8) | (red << 16);
                    }
                    
                }

                // 绘制圆形
                // 画圆
                
                for index in (width * height/2+width*5)..(width * height) {
                    let y1 = (index / width) as i32;
                    let x1 = (index % width) as i32;                   
                    let x0 = ((width/4)*3) as i32;
                    let y0 = ((height/4)*3) as i32;
                    let red = 169;
                    let green = 123;
                    let blue = 62;

                    if ((y1-y0)*(y1-y0)+(x1-x0)*(x1-x0))<2048*9 {
                        buffer[index as usize] = 0 | (0 << 8) | (255 << 16);
                    }
                    else {
                        buffer[index as usize] = blue | (green << 8) | (red << 16);
                    }
                    
                }
                

                // 绘制矩形
                // 画矩形
                
                for index in (width * height/2+width*5)..(width * height) {
                    let y1 = (index / width) as i32;
                    let x1 = (index % width) as i32;                   
                    let x0 = (width/2 - 180) as i32;
                    let y0 = ((height/2)+80) as i32;

                    let num_x = x1 - x0;//(x1.checked_sub(x0)).and_then(|dx| dx.checked_add(0));
                    let num_y = (y1.checked_sub(y0)).and_then(|dy| dy.checked_add(0));

                    if (num_x.abs()<100 && num_y<100_i32.checked_add(0_i32)) {
                        buffer[index as usize] = 255 | (0 << 8) | (0 << 16);
                    }
                    else{
                        //buffer[index as usize] = blue | (green << 8) | (red << 16);
                    }
                    
                }
                
                // 显示缓冲区内容
                buffer.present().unwrap();
            }
            // 当窗口关闭请求时
            Event::WindowEvent {
                event: WindowEvent::CloseRequested,
                window_id,
            } if window_id == window.id() => {
                // 退出事件循环
                elwt.exit();
            }
            // 忽略其他事件
            _ => {}
        }
    }).unwrap();
}

 效果图