初试Rust

最近这些年的程序设计语言发展趋势从C->C++->Java->Python->Go从一开始引入面向对象，后面又引入垃圾收集gc。我一直很纳闷，怎么这些语言越发展越复杂，都不是为了解决问题而生，而是引入各种概念，各种模式，说一堆人听不懂的东西，显得牛逼，所以这些年C语言才一直这么活跃，只有C语言才是为了解决问题而生。不过最近看到Rust才看到了一串曙光，网上有人形容Rust是近15年最佳软件工程实践的集大成者。我比较认可，Rust里面没有class的概念，但是也可以实现多态，同时还有很多有用的函数式编程，也没有gc。安全，性能又快。唯一的缺点可能就是比较难学了，所以造成使用的人一直比较少，不过我相信好东西会慢慢火起来的。

目前Rust没有好的IDE，只能使用vscode编写代码，另外配合windbg进行调试，前些年写代码一直在入口插int3然后使用windbg调试，没想到现在又派上了用场。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78


#![feature(asm)]

extern crate rand;
extern crate time;

use std::fs::File;
use std::io::prelude::*;
use rand::Rng;

fn init() {
    const FILE_NAME: &'static str = "sort.txt";
    let mut file = File::create(FILE_NAME).expect( "file create faile" );
    file.write_all(b"").expect( "file write fail" );
    let mut rd = rand::thread_rng();

    for _ in 0..1000_0000 {
        let tand = rd.gen_range( 1, 2000_0000 ).to_string() + "";
        file.write( tand.as_bytes()).expect( "file write fail!" );
    }
}

fn sort_by_self( ) {
    let mut byte:Vec<u32> = vec![0;625000];
    let mut file = File::open( "sort.txt" ).expect( "file open faile" );
    let mut buffer = String::new();

    file.read_to_string( &mut buffer ).unwrap();
    let hh = buffer.split( "" );
    for ll in hh {
        match ll.parse::<u32>() {
            Ok( num ) => {
                set_bit( &mut byte, num );
            }, 
            Err( _ ) => {
                println!( "That was not a number ..." );
            }
        }
    }

    let mut my_file = File::create( "new.txt" ).expect( "file create fail" );

    for x in 0..2000_0000 {
        let aa = get_bit( &mut byte, x );
        if aa != 0 {
            my_file.write( ( x.to_string() + "" ).as_bytes() ).unwrap();
        }
    }
}

fn set_bit( byte:&mut Vec<u32>, n:u32 ) {
    byte[ ( n / 32 ) as usize ] |= 1 << ( n % 32 );
}

fn get_bit( byte:&mut Vec<u32>, n:u32 ) -> u32 {
    byte[ ( n / 32) as usize ] & ( 1 << ( n % 32 ) )
}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
fn do_nothing() {
    unsafe {
        asm!( "int $$3" );
    }
}

fn main() {
    
    do_nothing();
    
    let start = time::now();
    init();
    let end = time::now();
    println!( "duration:{:?}", end - start );

    let start = time::now();
    sort_by_self();
    let end = time::now();
    println!( "duration:{:?}", end - start );
}

这是一个简单的使用位图排序的算法。

文章目录