repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 7
values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/智能指针/src/bin/weak_pointer.rs | rust基础/智能指针/src/bin/weak_pointer.rs | use std::{
cell::RefCell,
rc::{Rc, Weak},
};
fn main() {
let car = Rc::new(Car {
name: "国货之光-仰望U8".to_string(),
wheels: RefCell::new(vec![]),
});
let wheel1 = Rc::new(Wheel {
id: 1,
car: car.clone(),
});
let wheel2 = Rc::new(Wheel {
id: 2,
car: car.clone(),
});
let wheel3 = Rc::new(Wheel {
id: 3,
car: car.clone(),
});
let wheel4 = Rc::new(Wheel {
id: 4,
car: car.clone(),
});
{
let mut wheels = car.wheels.borrow_mut();
// 调用downgrade得到Weak
wheels.push(Rc::downgrade(&wheel1));
wheels.push(Rc::downgrade(&wheel2));
wheels.push(Rc::downgrade(&wheel3));
wheels.push(Rc::downgrade(&wheel4));
}
for week_wheel in car.wheels.borrow().iter() {
// 调用upgrade得到Rc
let tmp = week_wheel.upgrade().unwrap();
println!("wheel:{:?} owned by {:?}", tmp.id, tmp.car.name);
}
}
struct Car {
name: String,
wheels: RefCell<Vec<Weak<Wheel>>>,
}
struct Wheel {
id: i32,
car: Rc<Car>,
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/智能指针/src/bin/cow.rs | rust基础/智能指针/src/bin/cow.rs | use std::borrow::Cow;
fn main() {
fn delete_space<'a>(src: &'a str) -> Cow<'a, str> {
if src.contains(' ') {
let mut dest = String::with_capacity(src.len());
for c in src.chars() {
if ' ' != c {
dest.push(c);
}
}
return Cow::Owned(dest);
}
return Cow::Borrowed(src);
}
let a = "我想买 U8";
println!("a:{a}");
let b = delete_space(a);
println!("b:{b}");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/智能指针/src/bin/cell_and_refcell.rs | rust基础/智能指针/src/bin/cell_and_refcell.rs | use std::{
borrow::Borrow,
cell::{Cell, RefCell},
collections::HashMap,
ops::{Add, Shl},
rc::Rc,
};
fn main() {
// Cell
let regan = Student {
age: 30,
id: Cell::new(10000000888),
};
println!("regan:{:?}", regan);
// 编译报错，age不可变
//regan.age = 28;
// regan.id = Cell::new(String::from("513822199xxxxx"));
regan.id.set(10000000999);
println!("student id:{:?} regan:{:?}", regan.id.get(), regan);
// RefCell
let dog = Animal {
age: 3,
weight: RefCell::new(10.5),
name: RefCell::new(String::from("小憨包")),
};
println!("dog:{:?}", dog);
// 修改weight
*dog.weight.borrow_mut() += 10.1;
// 修改name
*dog.name.borrow_mut() = String::from("憨憨");
println!("dog weight:{:?}", dog);
// Rc和RefCell组建共享可被修改的数据结构
let shared_map: Rc<RefCell<HashMap<&str, i32>>> = Rc::new(RefCell::new(HashMap::new()));
println!("strong count :{}", Rc::strong_count(&shared_map));
{
let shared_map2 = shared_map.clone();
println!("strong count :{}", Rc::strong_count(&shared_map));
let mut map = shared_map.borrow_mut();
map.insert("lucky", 1);
map.insert("regan", 2);
map.insert("lily", 3);
map.insert("pop", 4);
}
println!("strong count :{}", Rc::strong_count(&shared_map));
}
#[derive(Debug)]
struct Student {
age: u8,
id: Cell<i64>,
}
#[derive(Debug)]
struct Animal {
age: u8,
weight: RefCell<f32>,
name: RefCell<String>,
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/异常处理/src/bin/option_and_result.rs | rust基础/异常处理/src/bin/option_and_result.rs | fn main() {
// or 和 and方法
// Option
let s1 = Some("123");
let s2 = Some("234");
let s3: Option<&str> = None;
assert_eq!(s1.or(s2), s1);
assert_eq!(s1.and(s2), s2);
assert_eq!(s1.and(s3), s3);
assert_eq!(s1.or(s3), s1);
// Result
let ok1: Result<&str, &str> = Ok("ok1");
let ok2: Result<&str, &str> = Ok("ok2");
let err1: Result<&str, &str> = Err("err1");
let err2: Result<&str, &str> = Err("err2");
assert_eq!(ok1.and(ok2), ok2);
assert_eq!(ok1.or(ok1), ok1);
assert_eq!(ok1.and(err1), err1);
assert_eq!(ok1.or(err1), ok1);
assert_eq!(err1.and(err2), err1);
assert_eq!(err1.or(err2), err2);
// or_else 和 and_then
let fn_some = || Some("234");
let fn_some2 = |_| Some("234");
assert_eq!(s2.or_else(fn_some), s2);
assert_eq!(s2.and_then(fn_some2), fn_some());
let fn_ok1 = |_| Ok("ok1");
let fn_ok2 = |_| Ok("ok2");
let fn_err1 = |_| Err("err1");
let fn_err2 = |_| Err("err2");
assert_eq!(ok1.or_else(fn_ok1), ok1);
assert_eq!(ok2.and_then(fn_ok2), ok2);
assert_eq!(err1.or_else(fn_err1), err1);
assert_eq!(err2.and_then(fn_err2), err2);
// 过滤和转换
// Option过滤
let closure_fn = |x: &&str| x.starts_with("123");
assert_eq!(s1.filter(closure_fn), Some("123"));
assert_eq!(s2.filter(closure_fn), None);
// Option和Result map和map_err转换
// map
let char_count = |s: &str| -> usize { s.chars().count() };
assert_eq!(s1.map(char_count), Some(3));
assert_eq!(s3.map(char_count), None);
assert_eq!(ok1.map(char_count), Ok(3));
assert_eq!(err1.map(char_count), Err("err1"));
// map_err
let map_err_char_count = |s: &str| s.chars().count();
assert_eq!(ok1.map_err(map_err_char_count), Ok("ok1"));
assert_eq!(err1.map_err(map_err_char_count), Err(4));
// Option和Result map_or和map_or_else提供默认值
// map_or
const DEFAULT: usize = 1;
let fn_closure = |s: &str| s.chars().count();
assert_eq!(s1.map_or(DEFAULT, fn_closure), 3);
assert_eq!(s3.map_or(DEFAULT, fn_closure), 1);
assert_eq!(ok1.map_or(DEFAULT, fn_closure), 3);
assert_eq!(err1.map_or(DEFAULT, fn_closure), 1);
// map_or_else
// 这个闭包可以对Err值进行处理
let fn_closure_default_value = |s: &str| s.chars().count() + 100;
assert_eq!(err1.map_or_else(fn_closure_default_value, fn_closure), 104);
// 将Option转换为Result
// ok_or 和 ok_or_else
assert_eq!(s1.ok_or("Error Message"), Ok("123"));
assert_eq!(s3.ok_or("Error Message"), Err("Error Message"));
let fn_closure = || "Error Message";
assert_eq!(s1.ok_or_else(fn_closure), Ok("123"));
assert_eq!(s3.ok_or_else(fn_closure), Err("Error Message"));
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/异常处理/src/bin/self_define_error_type.rs | rust基础/异常处理/src/bin/self_define_error_type.rs | use std::{
fmt::Debug,
fs::File,
io::{self, ErrorKind},
};
fn main() {
fn get_a_err1() -> Result<(), MyError> {
Err(MyError {
code: 404,
message: String::from("找不到页面"),
})
}
fn get_a_err2() -> Result<(), MyError> {
Err(MyError {
code: 500,
message: String::from("系统错误"),
})
}
println!("{:?}", get_a_err1());
println!("{:?}", get_a_err2());
let r = use_my_error_unified_process();
match r {
Ok(_) => println!("ok"),
Err(myerror) => println!("{:?}", myerror),
}
}
fn use_my_error_unified_process() -> Result<(), MyError> {
// 使用MyError进行错误类型归一化
// open方法抛出的io::Error将自动转换为MyError
// 因为MyError实现了From特征
let _f = File::open("./src/bin/hello.txt")?;
Ok(())
}
struct MyError {
code: usize,
message: String,
}
// 实现Debug特征
impl Debug for MyError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "Error {{code:{},message:{}}}", self.code, self.message)
}
}
// 为io::Error实现From接口
impl From<io::Error> for MyError {
fn from(error: io::Error) -> Self {
match error.kind() {
ErrorKind::NotFound => MyError {
code: 100001,
message: error.to_string(),
},
ErrorKind::PermissionDenied => MyError {
code: 100002,
message: error.to_string(),
},
_ => MyError {
code: 100003,
message: error.to_string(),
},
}
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/异常处理/src/bin/result.rs | rust基础/异常处理/src/bin/result.rs | fn main() {
println!("Hello, world!");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/异常处理/src/bin/use_anyhow.rs | rust基础/异常处理/src/bin/use_anyhow.rs | use std::{fs::File, io::Read};
use anyhow::{ Error, Ok, Result};
fn main() -> Result<()> {
let result = test_fn();
println!("{:?}",result);
Ok(())
}
fn test_fn() -> Result<String,Error> {
let data_path = std::env::var("DATA_PATH")?;
let mut file = File::open(data_path)?;
let mut buf = String::new();
let _ = file.read_to_string(&mut buf);
println!("content:{}", buf);
Ok(buf)
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/异常处理/src/bin/use_thiserror.rs | rust基础/异常处理/src/bin/use_thiserror.rs | use std::{fs::File, io::Read};
#[warn(dead_code)]
fn main() {
let r = test_fn();
match r {
Ok(s) => println!("{s}"),
Err(myerror) => println!("error:{:?}", myerror),
}
}
fn test_fn() -> Result<String, MyError> {
let data_path = std::env::var("DATA_PATH")?;
let mut file = File::open(data_path)?;
let mut buf = String::new();
let _ = file.read_to_string(&mut buf);
println!("content:{}", buf);
Ok(buf)
}
#[derive(Debug, thiserror::Error)]
enum MyError {
#[error("没有找到环境变量")]
EnvironmentNotFound(#[from] std::env::VarError),
#[error("IO错误")]
IoError(#[from] std::io::Error),
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/异常处理/src/bin/open_file_with_result.rs | rust基础/异常处理/src/bin/open_file_with_result.rs | use std::{
fs::File,
io::{Error, ErrorKind, Read, Write},
};
fn main() -> Result<(), Error> {
let file = File::open("./src/bin/result.txt");
// file是Result<File,Error>类型。现在做模式匹配
let mut file = match file {
Ok(file) => file,
Err(err) => match err.kind() {
ErrorKind::NotFound => match File::create("./src/bin/result.txt") {
Ok(f) => f,
Err(e) => panic!("文件不存在且创建文件失败:{e}"),
},
ErrorKind::PermissionDenied => panic!("没有打开权限"),
// 其它异常
_ => panic!("遇到未知异常"),
},
};
// 写入数据
let _ = file.write_all("2024加油!".as_bytes());
// 读取数据
let mut file = File::open("./src/bin/result.txt")?;
let mut content: String = String::new();
let _ = file.read_to_string(&mut content);
println!("{content}");
Ok(())
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/异常处理/src/bin/open_file_v2.rs | rust基础/异常处理/src/bin/open_file_v2.rs | pub mod use_thiserror;
use std::{
fs::File,
io::{Error, ErrorKind, Read, Write},
};
fn main() -> Result<(), Error> {
let mut file = File::open("./src/bin/result.txt").expect("打开文件失败");
// 写入数据
let _ = file.write_all("2024加油!".as_bytes());
// 读取数据
let mut file = File::open("./src/bin/result.txt").unwrap();
let mut content: String = String::new();
let _ = file.read_to_string(&mut content);
println!("{content}");
// ?运算符向上层抛出异常
let content = read_from_file();
match content {
Ok(c) => println!("content:{c}"),
Err(e) => println!("error:{:?}", e),
}
Ok(())
}
fn read_from_file() -> Result<String, Error> {
// 文件不存在，?直接返回Error
let mut file = File::open("./src/bin/result1.txt")?;
let mut result = String::new();
let _ = file.read_to_string(&mut result);
Ok(result)
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/hello/src/main.rs | rust基础/hello/src/main.rs | fn main() {
println!("Hello, world!");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/pin_and_unpin/src/bin/pin_rabbit_heap.rs | rust基础/pin_and_unpin/src/bin/pin_rabbit_heap.rs | use std::marker::PhantomPinned;
use std::pin::Pin;
/// 将值Pin在栈上
// 创建一个自引用类型的兔子结构体
#[derive(Debug)]
struct Rabbit {
name: String,
p: *const String,
_marker: PhantomPinned,
}
impl Rabbit {
fn new(txt: &str) -> Pin<Box<Self>> {
let rabbit = Rabbit {
name: String::from(txt),
p: std::ptr::null(),
// 这个标记可以让Rabbit自动实现!Unpin
_marker: PhantomPinned,
};
let mut boxed = Box::pin(rabbit);
let self_ptr: *const String = &boxed.as_ref().name;
unsafe { boxed.as_mut().get_unchecked_mut().p = self_ptr };
boxed
}
fn name(self: Pin<&Self>) -> &str {
&self.get_ref().name
}
fn p_value(self: Pin<&Self>) -> &String {
assert!(
!self.p.is_null(),
"Rabbit::p_value called without Rabbit::init being called first"
);
unsafe { &*(self.p) }
}
}
fn main() {
let mut rabbit1 = Rabbit::new("小白");
let mut rabbit2 = Rabbit::new("小黑");
println!("rabbit1 name: {}, rabbit1 p_value: {} rabbit1 name addr:{:p} rabbit1 p addr:{:p} rabbit1 addr:{:p}",
Rabbit::name(rabbit1.as_ref()), Rabbit::p_value(rabbit1.as_ref()),&rabbit1.name,rabbit1.p,&rabbit1);
println!("rabbit2 name: {}, rabbit2 p_value: {} rabbit2 name addr:{:p} rabbit2 p addr:{:p} rabbit2 addr:{:p}",
Rabbit::name(rabbit2.as_ref()), Rabbit::p_value(rabbit2.as_ref()),&rabbit2.name,rabbit2.p,&rabbit2);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/pin_and_unpin/src/bin/async_concurrent_mult_thread_web_server.rs | rust基础/pin_and_unpin/src/bin/async_concurrent_mult_thread_web_server.rs | use std::{fs,time::Duration};
use async_std::net::TcpListener;
use async_std::net::TcpStream;
use async_std::task;
use futures::stream::StreamExt;
use async_std::prelude::*;
use async_std::task::spawn;
#[async_std::main]
async fn main() {
let listener = TcpListener::bind("127.0.0.1:12345").await.unwrap();
listener
.incoming()
.for_each_concurrent(None, |tcpstream| async move {
let tcpstream = tcpstream.unwrap();
spawn(handle_connection(tcpstream));
})
.await;
}
async fn handle_connection(mut stream:TcpStream){
let mut buffer = [0;1024];
stream.read(&mut buffer).await.unwrap();
let get = b"GET / HTTP/1.1\r\n";
let sleep = b"GET /sleep HTTP/1.1\r\n";
let (status_line, filename) = if buffer.starts_with(get) {
("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
} else if buffer.starts_with(sleep) {
task::sleep(Duration::from_secs(5)).await;
("HTTP/1.1 200 OK\r\n\r\n", "sleep.html")
} else {
("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
};
let contents = fs::read_to_string(filename).unwrap();
let response = format!("{status_line}{contents}");
stream.write(response.as_bytes()).await.unwrap();
stream.flush().await.unwrap();
} | rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/pin_and_unpin/src/bin/async_std_web_server.rs | rust基础/pin_and_unpin/src/bin/async_std_web_server.rs | use std::{fs, io::{Read, Write}, net::{TcpListener, TcpStream}, time::Duration};
use async_std::task;
#[async_std::main]
async fn main() {
let listener = TcpListener::bind("127.0.0.1:12345").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
// 警告，这里无法并发
handle_connection(stream).await;
}
}
async fn handle_connection(mut stream:TcpStream){
let mut buffer = [0;1024];
stream.read(&mut buffer).unwrap();
let get = b"GET / HTTP/1.1\r\n";
let sleep = b"GET /sleep HTTP/1.1\r\n";
let (status_line, filename) = if buffer.starts_with(get) {
("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
} else if buffer.starts_with(sleep) {
task::sleep(Duration::from_secs(5)).await;
("HTTP/1.1 200 OK\r\n\r\n", "sleep.html")
} else {
("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
};
let contents = fs::read_to_string(filename).unwrap();
let response = format!("{status_line}{contents}");
stream.write(response.as_bytes()).unwrap();
stream.flush().unwrap();
} | rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/pin_and_unpin/src/bin/pin_rabbit_stack.rs | rust基础/pin_and_unpin/src/bin/pin_rabbit_stack.rs | use std::marker::PhantomPinned;
use std::pin::Pin;
/// 将值Pin在栈上
// 创建一个自引用类型的兔子结构体
#[derive(Debug)]
struct Rabbit {
name: String,
p: *const String,
_marker: PhantomPinned,
}
impl Rabbit {
fn new(txt: &str) -> Self {
Rabbit {
name: String::from(txt),
p: std::ptr::null(),
// 这个标记可以让Rabbit自动实现!Unpin
_marker: PhantomPinned,
}
}
fn init(self: Pin<&mut Self>) {
let self_ref: *const String = &self.name;
let this = unsafe { self.get_unchecked_mut() };
this.p = self_ref;
}
fn name(self: Pin<&Self>) -> &str {
&self.get_ref().name
}
fn p_value(self: Pin<&Self>) -> &String {
assert!(
!self.p.is_null(),
"Rabbit::p_value called without Rabbit::init being called first"
);
unsafe { &*(self.p) }
}
}
fn main() {
let mut rabbit1 = Rabbit::new("小白");
let mut rabbit1 = unsafe { Pin::new_unchecked(&mut rabbit1) };
Rabbit::init(rabbit1.as_mut());
let mut rabbit2: Rabbit = Rabbit::new("小黑");
let mut rabbit2 = unsafe { Pin::new_unchecked(&mut rabbit2) };
Rabbit::init(rabbit2.as_mut());
println!("rabbit1 name: {}, rabbit1 p_value: {} rabbit1 name addr:{:p} rabbit1 p addr:{:p} rabbit1 addr:{:p}",
Rabbit::name(rabbit1.as_ref()), Rabbit::p_value(rabbit1.as_ref()),&rabbit1.name,rabbit1.p,&rabbit1);
println!("rabbit2 name: {}, rabbit2 p_value: {} rabbit2 name addr:{:p} rabbit2 p addr:{:p} rabbit2 addr:{:p}",
Rabbit::name(rabbit2.as_ref()), Rabbit::p_value(rabbit2.as_ref()),&rabbit2.name,rabbit2.p,&rabbit2);
println!("--------------------------------------------------------------------------------------------");
// std::mem::swap函数用于交换两个内存地址处的值
// 由于rabbit1和rabbit2都被Pin住了，所有swap移动值直接编译报错
std::mem::swap(rabbit1.get_mut(), rabbit2.get_mut());
//println!("rabbit1 name: {}, rabbit1 p_value: {} rabbit1 name addr:{:p} rabbit1 p addr:{:p} rabbit1 addr:{:p}",
// Rabbit::name(rabbit1.as_ref()), Rabbit::p_value(rabbit1.as_ref()),&rabbit1.name,rabbit1.p,&rabbit1);
//println!("rabbit2 name: {}, rabbit2 p_value: {} rabbit2 name addr:{:p} rabbit2 p addr:{:p} rabbit2 addr:{:p}",
// Rabbit::name(rabbit2.as_ref()), Rabbit::p_value(rabbit2.as_ref()),&rabbit2.name,rabbit2.p,&rabbit2);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/pin_and_unpin/src/bin/async_concurrent_single_thread_web_server.rs | rust基础/pin_and_unpin/src/bin/async_concurrent_single_thread_web_server.rs | use std::{fs,time::Duration};
use async_std::net::TcpListener;
use async_std::net::TcpStream;
use async_std::task;
use futures::stream::StreamExt;
use async_std::prelude::*;
#[async_std::main]
async fn main() {
let listener = TcpListener::bind("127.0.0.1:12345").await.unwrap();
listener
.incoming()
.for_each_concurrent(None, |tcpstream| async move {
let tcpstream = tcpstream.unwrap();
handle_connection(tcpstream).await;
})
.await;
}
async fn handle_connection(mut stream:TcpStream){
let mut buffer = [0;1024];
stream.read(&mut buffer).await.unwrap();
let get = b"GET / HTTP/1.1\r\n";
let sleep = b"GET /sleep HTTP/1.1\r\n";
let (status_line, filename) = if buffer.starts_with(get) {
("HTTP/1.1 200 OK\r\n\r\n", "hello.html")
} else if buffer.starts_with(sleep) {
task::sleep(Duration::from_secs(5)).await;
("HTTP/1.1 200 OK\r\n\r\n", "sleep.html")
} else {
("HTTP/1.1 404 NOT FOUND\r\n\r\n", "404.html")
};
let contents = fs::read_to_string(filename).unwrap();
let response = format!("{status_line}{contents}");
stream.write(response.as_bytes()).await.unwrap();
stream.flush().await.unwrap();
} | rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/pin_and_unpin/src/bin/self_ref.rs | rust基础/pin_and_unpin/src/bin/self_ref.rs | // 创建一个自引用类型的兔子结构体
#[derive(Debug)]
struct Rabbit {
name: String,
p: *const String,
}
impl Rabbit {
fn new(txt: &str) -> Self {
Rabbit {
name: String::from(txt),
p: std::ptr::null(),
}
}
fn init(&mut self) {
let self_ref: *const String = &self.name;
self.p = self_ref;
}
fn name(&self) -> &str {
&self.name
}
fn p_value(&self) -> &String {
assert!(
!self.p.is_null(),
"Rabbit::p_value called without Rabbit::init being called first"
);
unsafe { &*(self.p) }
}
}
fn main() {
let mut rabbit1 = Rabbit::new("小白");
rabbit1.init();
let mut rabbit2: Rabbit = Rabbit::new("小黑");
rabbit2.init();
println!("rabbit1 name: {}, rabbit1 p_value: {} rabbit1 name addr:{:p} rabbit1 p addr:{:p} rabbit1 addr:{:p}",
rabbit1.name(), rabbit1.p_value(),&rabbit1.name,rabbit1.p,&rabbit1);
println!("rabbit2 name: {}, rabbit2 p_value: {} rabbit2 name addr:{:p} rabbit2 p addr:{:p} rabbit2 addr:{:p}",
rabbit2.name(), rabbit2.p_value(),&rabbit2.name,rabbit2.p,&rabbit2);
println!("--------------------------------------------------------------------------------------------");
// std::mem::swap函数用于交换两个内存地址处的值
std::mem::swap(&mut rabbit1, &mut rabbit2);
println!("rabbit1 name: {}, rabbit1 p_value: {} rabbit1 name addr:{:p} rabbit1 p addr:{:p} rabbit1 addr:{:p}",
rabbit1.name(), rabbit1.p_value(),&rabbit1.name,rabbit1.p,&rabbit1);
println!("rabbit2 name: {}, rabbit2 p_value: {} rabbit2 name addr:{:p} rabbit2 p addr:{:p} rabbit2 addr:{:p}",
rabbit2.name(), rabbit2.p_value(),&rabbit2.name,rabbit2.p,&rabbit2);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/pin_and_unpin/src/bin/single_thread_web_server.rs | rust基础/pin_and_unpin/src/bin/single_thread_web_server.rs | use std::{fs, io::{Read, Write}, net::{TcpListener, TcpStream}};
// 单线程版本的web服务
fn main() {
// 监听本地端口 12345
let listener = TcpListener::bind("127.0.0.1:12345").unwrap();
// 阻塞等待请求进入
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
fn handle_connection(mut stream: TcpStream) {
// 从链接中读取1024个字节的数据
let mut buffer = [0; 1024];
stream.read(&mut buffer).unwrap();
let get = b"GET / HTTP/1.1\r\n";
// 处理请求
let (status_line, file_name) = if buffer.starts_with(get) {
("HTTP/1.1 200 OK \r\n\r\n", "hello.html")
} else {
("HTTP/1.1 404 NOT FOUND", "404.html")
};
// 回复内容
println!("status line:{status_line} file_name:{file_name}");
let contents = fs::read_to_string(file_name).unwrap();
let response = format!("{status_line}{contents}");
println!("response {response}");
// 写数据到stream
stream.write_all(response.as_bytes()).unwrap();
// 刷新
stream.flush().unwrap();
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/泛型/src/main.rs | rust基础/泛型/src/main.rs | use std::{
cmp::max,
fmt::{Debug, Display},
ops::{Add, Mul},
};
fn main() {
// 编译阶段T被替换为i32类型
let s: i32 = sum(120, 20);
println!("s:{s}");
// 编译阶段T被替换为f32类型
let s: f32 = sum(120_f32, 20_f32);
println!("s:{s}");
let arr = [1, 2, 3, 4, 5, 6];
let lar = largest(&arr);
println!("最大值:{lar}");
let arr1 = ["a", "ff", "yf", "f"];
let lar = largest(&arr1);
println!("最大值:{lar}");
// 结构体中的泛型
let rectangle = Rectangle {
length: 39,
width: 89,
};
println!("周长:{},面积:{}", rectangle.perimeter(), rectangle.area());
let rectangle = Rectangle {
length: 3.14,
width: 89.77,
};
println!("周长:{},面积:{}", rectangle.perimeter(), rectangle.area());
// 枚举中使用泛型,T由具体的类型进行替换
let some_data: Option<i32> = Some(123);
// 使用if let进行模式匹配，将Some同的值绑定到data上
// 如果匹配成功，将打印出data数值
if let Some(data) = some_data {
println!("data:{data}");
}
// 使用_占位，并由Ok中的123推断出_的类型为i32
// 对于Result中的E类型，需要显示指定类型，否则编译不通过
let result: Result<_, &str> = Ok(123);
if let Ok(data) = result {
println!("ok data:{data}");
}
// 特殊的泛型
let a = [1, 3, 4, 5];
let b = [3, 4, 5];
// 调用接收数组切片的函数，打印
let c = ["a", "c", "m"];
print1(&a);
print1(&b);
print1(&c);
print2(a);
print2(b);
print2(c);
}
// 接收数组切片的函数
// 泛型参数T的泛型限定为Debug，Rust内置的打印特征
// 表示T是可以被打印输出的
fn print1<T: Debug>(a: &[T]) {
println!("a={:?}", a);
}
// 另外一种打印数组的泛型方法
// T泛型限定为Debug，可打印
// N应该为一个数量,使用usize进行限定是不行的
// 因为usize是一个数据类型，需要加上const
// 表示这是一个const类型的泛型且是一个数值类型
fn print2<T: Debug, const N: usize>(a: [T; N]) {
println!("a={:?}", a);
}
// 定义泛型函数，泛型需要再尖括号中声明才能使用
fn sum<T: Add<T, Output = T>>(a: T, b: T) -> T {
a + b
}
// 定义泛型函数，求最大值
// 函数参数为T类型的切片
// 返回值为T
// 要比较切片中的值，需要为T增加一个约束，让T可以比较
// 使用Rust内置的PartialOrd特征约束,实现该特征的类型具有可比较性
fn largest<T: PartialOrd>(list: &[T]) -> &T {
let mut largest = &list[0];
for item in list.iter() {
if item > largest {
largest = item;
}
}
largest
}
// 结构体中使用泛型
struct Rectangle<U> {
length: U,
width: U,
}
impl<U: Mul<U, Output = U> + Add<U, Output = U> + Copy + PartialOrd> Rectangle<U> {
/// 求周长，该方法返回值是泛型
fn perimeter(&self) -> U {
self.length + self.width + self.length + self.width
}
/// 求面积，该方法返回值是泛型
fn area(&self) -> U {
self.length * self.width
}
/// maxrectangle构造并返回最大的矩形
fn max_rectangle(&self, other: Self) -> Rectangle<U> {
let mut max_length = self.length;
if other.length > self.length {
max_length = other.length;
}
let mut max_width = self.width;
if other.width > self.width {
max_width = other.width;
}
Self {
length: max_length,
width: max_width,
}
}
}
// 使用where语句将尖括号中的特征限定，拿到尖括号外
impl<U> Rectangle<U>
where U: Mul<U, Output = U>+ Add<U, Output = U> + Copy + PartialOrd
{
/// maxrectangle构造并返回最大的矩形
fn max_rectangle_1(&self, other: Self) -> Rectangle<U> {
let mut max_length = self.length;
if other.length > self.length {
max_length = other.length;
}
let mut max_width = self.width;
if other.width > self.width {
max_width = other.width;
}
Self {
length: max_length,
width: max_width,
}
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/rust_编程规范/src/main.rs | rust基础/rust_编程规范/src/main.rs | //! 熟悉Rust中的各种约定用法
//! 熟悉Rust中的基本概念
#[warn(unused_variables)]
#[warn(non_snake_case)]
fn main() {
let result1: i32 = sum(10, 20);
assert_eq!(30, result1);
// 函数默认返回类型为单元类型
let result2: () = test_function();
// 使用println!宏来打印输出，使用{result1}作为占位符，用于输出result1;使用{:?}作为占位符，输出result2。
// 因为单元类型没有实现Display Trait，所以需要使用{:?}方式来格式化
println!("result1 = {result1} , result2 = {:?}", result2);
println!("smile:{}", test_function1());
println!("sum1:{}", sum1(10, 20));
naming_example();
// 等待不退出，便于运行可执行文件查看打印信息
loop {}
}
/// 求两个数的和
pub fn sum(a: i32, b: i32) -> i32 {
a + b
}
/// 无参数 无显示的返回值 默认返回单元类型()
pub fn test_function() {
println!("你好，世界");
}
fn test_function1() -> char {
// 单行注释
/* 单行注释 */
/*
多行注释
可以换行
*/
'\u{1F600}'
}
///计算两数之和
/// 用法：
/// ```
/// let result = sum1(10,20);
/// assert_eq!(result,30);
/// ```
///
fn sum1(a: i32, b: i32) -> i32 {
a + b
}
/// 命名风格示例
#[warn(dead_code)]
fn naming_example() {
// 枚举,泛型参数T和E
enum Result<T, E> {
Ok(T),
Err(E),
}
// 特征Trait，泛型参数T，返回Self实例
trait From<I> {
fn from() -> Self;
}
// 结构体
struct Student {
age: u32,
height: f32,
}
// 为结构体实现方法
impl Student {
// 构造函数，它是关联函数
fn new(age: u32, height: f32) -> Self {
Self { age, height }
}
// 定义其它方法
fn get_age(&self) -> u32 {
self.age
}
}
// 静态变量
static HODOOP_HOME: &str = "/data/softwares/hadoop-3.2.2";
// 常量
const VERSION: i32 = 33;
// 定义宏
macro_rules! add {
($a:expr,$b:expr) => {
$a + $b
};
}
// 使用宏
let result = add!(2, 3);
// 断言
assert_eq!(result, 5);
} | rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/集合了集合/src/bin/hashmap.rs | rust基础/集合了集合/src/bin/hashmap.rs | use std::collections::HashMap;
fn main() {
// 使用关联函数new创建
let mut map = HashMap::new();
map.insert("lucky".to_string(), 95);
map.insert("lily".to_string(), 100);
println!("map:{:?}", map);
// 使用迭代器+collect创建
let props = vec![("lucky".to_string(), 95), ("lily".to_string(), 100)];
let mut map: HashMap<_, _> = props.into_iter().collect();
println!("map:{:?}", map);
// 所有权的转移
let name = "pop".to_string();
let score = 88;
map.insert(name, score);
println!("map:{:?}", map);
// 下面代码name报错，name是String类型没有实现Copy,发生所有权转移，不能再继续使用
// age是标量，实现了Copy不会发所有权转移
//println!("name:{name} age:{score}");
// HashMap查询和更新
// 使用get按key查询，查询不到返回None，查询到返回Some(T)
let score = map.get("pip");
println!("score:{:?}",score);
let score = map.get("pop");
println!("score:{:?}",score);
// 返回值是Option枚举类型，如果要获取值可以使用unwrap方法
println!("score :{}",score.unwrap());
// 按key更新HashMap中的值
map.insert("pip".to_string(), 88);
// 查询pipp，若不存在则插入新值
let value = map.entry("pipp".to_string()).or_insert(199);
// 返回了一个可变引用，可以借助它来更新值
*value = *value + 100;
println!("插入新值:{:?}",map.get("pipp"));
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/集合了集合/src/bin/vec.rs | rust基础/集合了集合/src/bin/vec.rs | fn main() {
// 动态数组
// 使用vec!宏创建
let v = vec![2, 3, 4, 5, 6, 76];
println!("v:{:?}", v);
// 使用关联函数new创建
let mut vv: Vec<i32> = Vec::new();
// 使用push添加元素
vv.push(1);
vv.push(2);
vv.push(3);
println!("vv:{:?}", vv);
// 从动态数组中获取元素
println!("第6个元素:{:?}", v.get(6));
// 下面代码会panic，因为下标越界了
// println!("第6个元素:{:?}",&v[6]);
// 可变借用和不可变借用同时存在
// 不可变借用
let last_element = vv.last();
// 可变借用增加数据
vv.push(989);
// 注释掉下面的代码，程序正常运行
// 如果打开注释，last_element是不可变借用
// vv.push是可变借用，违反借用检查规则
//println!("last element:{:?}",last_element);
// 遍历动态数组元素
// 不可变借用遍历
for ele in &vv {
println!("ele1:{ele}");
}
// 可变借用遍历
for ele in &mut vv {
// 修改值
*ele += 1;
println!("ele2:{ele}");
}
// 带走所有权，后面将不能访问vv
for ele in vv {
println!("ele3:{ele}");
}
// 报错，vv所有权已被移走
//println!("vv:{:?}",vv);
// Vec存储不同类型的对象
// 第一种：存储枚举值
let mut pens = vec![];
pens.push(Pen::Pencil("铅笔".to_string()));
pens.push(Pen::ColorPen("彩色笔".to_string()));
for pen in &pens {
println!("{:?}", pen);
}
// 第二种：存储特征对象
let pens: Vec<Box<dyn Write>> = vec![
Box::new(Pencil {
name: "铅笔".to_string(),
}),
Box::new(ColorPen {
name: "彩色笔".to_string(),
}),
];
for pen in &pens {
pen.write();
}
// 排序
let mut num1 = vec![3, 4, 5, 6, 77, 9, 1, 2, 910];
num1.sort();
println!("升序排列：{:?}", num1);
// 倒序
num1.reverse();
println!("降序排列：{:?}", num1);
// 调用sort_unstable方法
num1.sort_unstable();
println!("升序排列：{:?}", num1);
let mut num2 = vec![1.1, 2.5, 0.78, 908.9];
// float数组，调用sort方法会报错，原因是
// float没有实现Ord特征
// 根本原因是浮点数没有实现全数值可比较，因为浮点数中有NaN值
// 但浮点数实现了部分可比较，当确定数组中不含NaN时，可以使用partial_cmp实现比较
//num2.sort();
num2.sort_by(|a, b| a.partial_cmp(b).unwrap());
println!("num2 升序排列:{:?}", num2);
num2.sort_by(|a, b| b.partial_cmp(a).unwrap());
println!("num2 降序排列:{:?}", num2);
// 对结构体进行排序
#[derive(Debug)]
struct Animal(i32, String);
let mut animals = vec![
Animal(1, "dog".to_string()),
Animal(99, "pig".to_string()),
Animal(98, "elephant".to_string()),
Animal(100, "hive".to_string()),
];
// 按动物的物种名称降序排列
animals.sort_by(|a, b| b.1.cmp(&a.1));
println!("按物种名称降序:{:?}", animals);
// vec上常见的方法使用
// 初始一个带10个容量的Vec数组
// 动态增加元素如果容量不足，会触发扩容。重新申请一块2倍大小的内存
// 在将所有元素拷贝到新的内存为止，同时更新vec在栈中的指针
// 频繁的扩容会降低性能，因此预定义一个合适的容量尤为重要
let mut num1: Vec<i32> = Vec::with_capacity(10);
println!(
"扩容前数据内存地址:{:p} 容量:{} 数组长度:{}",
&(*num1),
num1.capacity(),
num1.len()
);
// 批量添加数据
num1.extend([1, 3, 5, 33, 34, 99, 88, 77, 66]);
// 扩容到20
num1.reserve(20);
// 可以发现扩容前后内存地址不一样，证明重新申请了内存并拷贝了数据
println!(
"扩容后数据内存地址:{:p} 容量:{} 数组长度:{}",
&(*num1),
num1.capacity(),
num1.len()
);
// 释放剩余的容量
num1.shrink_to_fit();
println!("释放容量后容量:{} 数组长度:{}", num1.capacity(), num1.len());
// 断言是否为空
assert!(!num1.is_empty());
// 指定索引插入数据
num1.insert(1, 9999999);
assert!(9999999 == *num1.get(1).unwrap());
// 删除指定位置的数据
num1.remove(1);
// 删除并返回尾部的数据,如果没有数据返回None
let tail_num = num1.pop();
println!("tail num:{:?}", tail_num);
// 筛选满足条件的数据，并删除不满足条件的数据
num1.retain_mut(|x| *x > 10);
println!("删除小于等于10的数据后:{:?}", num1);
// 删除指定范围的数据,返回被删除数据的迭代器
let del_eles: Vec<i32> = num1.drain(0..2).collect();
println!("被删除的元素:{:?}", del_eles);
// 支持切片，用切片获取连续的数据
let slice: &[i32] = &num1[0..2];
assert!(slice == &[99, 88]);
// 清空
num1.clear();
}
#[derive(Debug)]
enum Pen {
Pencil(String),
ColorPen(String),
}
trait Write {
fn write(&self);
}
struct Pencil {
name: String,
}
impl Write for Pencil {
fn write(&self) {
println!("我用{}写字", self.name.as_str())
}
}
struct ColorPen {
name: String,
}
impl Write for ColorPen {
fn write(&self) {
println!("我用{}写字", self.name.as_str())
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生命周期/src/bin/lifecycle.rs | rust基础/生命周期/src/bin/lifecycle.rs | fn main() {
// 悬垂指针
// let age;
// {
// let age1 = 30;
// age = &age1;
// }
// println!("age:{age}");
// 生命周期标注语法
// 显式周期的引用 &'a u32
// 显式周期的可变引用 &'a mut u32
// 函数传参，显式标明生命周期
// 类似于泛型，要在尖括号中先声明才能使用
// 第一个参数是生命周期为'a的不可变引用
// 第二个参数是生命周期为'a的可变引用
fn bigest_age<'a>(age1: &'a i32, age2: &'a mut i32) -> &'a i32 {
println!("age1:{age1} age2:{age2}");
if age1 > age2 {
age1
} else {
age2
}
}
let age1 = 123;
let mut age2 = 73;
let max_age = bigest_age(&age1, &mut age2);
println!("max_age:{max_age}");
// 函数有两个一样的生命周期的参数，返回值的生命周期等于较小作用域的哪个值的生命周期
// let age1 = 123;
// let max_age;
// {
// let mut age2 = 73;
// max_age = bigest_age(&age1, &mut age2);
// }
// println!("max_age:{max_age}");
// 悬垂引用 编译不通过
// fn get_message<'a>()->&'a str{
// let msg = String::from("hello AI");
// msg.as_str()
// }
// 上述代码编译不通过，做如下修改，返回内部所有权
fn get_message() -> String {
String::from("hello AI")
}
// 结构体中的生命周期
#[derive(Debug)]
struct Message<'a> {
msg: &'a str,
}
impl<'a> Message<'a> {
fn new(msg: &'a str) -> Self {
Self { msg }
}
}
let say_hi = String::from("hi,how are you");
let message = Message {
msg: say_hi.as_str(),
};
println!("{:?}", message);
// 下面方式声明会报错
// let message;
// {
// let say_hi = String::from("hi,how are you");
// message = Message{msg:say_hi.as_str()};
// }
// println!("{:?}", message);
// 生命周期消除规则
/*
// 第一个例子
fn fun(msg:&str)->&str{msg};
// 编译器运用第一条规则，默认加上生命周期
fn fun<'a>(msg:&'a str)->&str{msg};
// 再运用第二条规则,确定返回值的声明周期
fn fun<'a>(msg:&'a str)->&'a str{msg};
// 第二个例子
fn fun(msg:&str,name:&str)->&str{msg};
// 编译器运用第一个规则，给输入引用默认加上独立生命周期
fn fun<'a,'b>(msg:&'a str,name:&'b str)->&str{msg};
// 此时第二个规则无法使用，地撒个规则也无法使用
// 这时需要手动标注生命周期才能解决了，手动标注rux
fn fun<'a,'b>(msg:&'a str,name:&'b str)->&'a str{msg};
*/
// 第三条规则，结构体方法中第一个参数是&self或&mut self
struct Animal<'a> {
name: &'a str,
}
impl<'a> Animal<'a> {
fn moo(&self, voice: &str) -> &str {
println!("the cows moo and moo:{voice}");
self.name
}
// moo等价于
fn moo1<'b>(&'a self, voice: &'b str) -> &'a str {
println!("the cows moo and moo:{voice}");
self.name
}
// 做个小的改动，返回voice
fn moo2<'b:'a>(&'a self, voice: &'b str) -> &'b str {
println!("the cows moo and moo:{voice}");
voice
}
// 和实现泛型约束一样，也可以使用where语法
fn moo3<'b>(&'a self, voice: &'b str) -> &'b str where 'b:'a {
println!("the cows moo and moo:{voice}");
voice
}
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/客户端服务端聊天chat/server/src/main.rs | rust基础/客户端服务端聊天chat/server/src/main.rs | use std::io::{ErrorKind, Read, Write};
use std::net::TcpListener;
use std::sync::mpsc;
use std::thread;
use std::time::Duration;
// 监听地址
const LOCAL: &str = "127.0.0.1:8888";
// 消息大小
const MSG_SIZE: usize = 32;
fn main() {
// 建立监听
let server = TcpListener::bind(LOCAL).expect("绑定失败");
// 设置server的accept方法为非阻塞
server.set_nonblocking(true).expect("设置失败");
// 接入进来的客户端集合
let mut clients = vec![];
// 基于channel消息传递机制，解耦建立监听和响应客户端这两件事
let (sender, receiver) = mpsc::channel::<String>();
loop {
// 建立客户端连接
if let Ok((mut socket, addr)) = server.accept() {
println!("Client {} connected", addr);
let sender = sender.clone();
clients.push(socket.try_clone().expect("克隆失败"));
// 新建线程，接收client消息，并将接收到的消息发送到channel
thread::spawn(move || loop {
// 初始化buff，默认值为0
let mut buff = vec![0; MSG_SIZE];
// 读取客户端发送的信息，存入指定长度的buff中
match socket.read_exact(&mut buff) {
Ok(_) => {
// 过滤出有效的字节
let msg = buff.into_iter().take_while(|&x| x != 0).collect::<Vec<_>>();
// 将有效字节转换成字符串
let msg = String::from_utf8(msg).expect("非法字符");
// 打印收到的消息
println!("{}-: {:?}", addr, msg);
// 将接收到的消息发送到channel
sender.send(msg).expect("发送消息到channel失败");
}
Err(ref err) if err.kind() == ErrorKind::WouldBlock => (),
Err(_) => {
println!("关闭连接: {}", addr);
break;
}
}
// 防止CPU打满
thread::sleep(Duration::from_millis(100));
});
}
// channel中有消息
if let Ok(msg) = receiver.try_recv() {
// 向所有客户端同步刚刚收到的消息
clients = clients
.into_iter()
.filter_map(|mut client| {
let mut buff = msg.clone().into_bytes();
buff.resize(MSG_SIZE, 0);
// 向每个客户端发送消息，并返回状态ok的客户端
client.write_all(&buff).map(|_| client).ok()
})
.collect::<Vec<_>>();
}
// 防止CPU打满
thread::sleep(Duration::from_millis(100));
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/客户端服务端聊天chat/client/src/main.rs | rust基础/客户端服务端聊天chat/client/src/main.rs | use std::io::{self, ErrorKind, Read, Write};
use std::net::TcpStream;
use std::sync::mpsc::{self, TryRecvError};
use std::thread;
use std::time::Duration;
// 服务端地址
const LOCAL: &str = "127.0.0.1:8888";
// 消息长度
const MSG_SIZE: usize = 32;
fn main() {
// 和客户端建立连接
let mut client = TcpStream::connect(LOCAL).expect("连接失败");
// 设置客户端所有的操作都为非阻塞
client.set_nonblocking(true).expect("设置非阻塞失败");
let (sender, receiver) = mpsc::channel::<String>();
// 新建线程，接收服务端消息
thread::spawn(move || loop {
// 缓存数组
let mut buff = vec![0; MSG_SIZE];
// 从简历的client连接上读取服务端发送的消息
match client.read_exact(&mut buff) {
Ok(_) => {
// 过滤出有效消息
let msg = buff.into_iter().take_while(|&x| x != 0).collect::<Vec<_>>();
println!(">>{:?}", String::from_utf8(msg).unwrap());
}
Err(ref err) if err.kind() == ErrorKind::WouldBlock => (),
Err(_) => {
println!("读取数据失败，终止连接");
break;
}
}
// 从channel中读取输入设备输入的消息
match receiver.try_recv() {
Ok(msg) => {
// 将消息读取缓存
let mut buff = msg.clone().into_bytes();
// 填充为指定大小的数组
buff.resize(MSG_SIZE, 0);
// 将消息通过连接写到服务端
client.write_all(&buff).expect("发送消息失败");
}
Err(TryRecvError::Empty) => (),
Err(TryRecvError::Disconnected) => break,
}
// 防止cpu打满
thread::sleep(Duration::from_millis(100));
});
// 打印tips
println!("使用技巧，输入 :quit 退出连接");
println!("请发送消息:");
loop {
// 缓存数组
let mut buff = String::new();
// 从标准输入读取数据到buff
io::stdin().read_line(&mut buff).expect("读取失败");
// 转换为字符串
let msg = buff.trim().to_string();
// 发送到channel
// 如果是:quit 或 发送消息到channel失败，退出主线程
if msg == ":quit" || sender.send(msg).is_err() {
break;
}
}
println!("再见!");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/unsafe的超能力/src/bin/raw_pointer.rs | rust基础/unsafe的超能力/src/bin/raw_pointer.rs | use std::{slice::from_raw_parts, str::from_utf8_unchecked};
fn main() {
create_raw_point();
//random_mem_addr_as_raw_pointer();
let hi = "Hi 2024";
// 获取“Hi 2024”的内存地址
let hi_addr = hi.as_ptr() as usize;
// 字符串长度
let len = hi.len();
// 从指定内存地址处读取指定长度的数据
let data = unsafe { from_utf8_unchecked(from_raw_parts(hi_addr as *const u8, len)) };
println!("data :{data}");
// unsafe代码
unsafe fn dangerous() {}
unsafe { dangerous() };
fn safe() {
unsafe { dangerous() };
}
safe();
// 使用extern声明这是一个C库中的方法
extern "C" {
fn abs(input: i32) -> i32;
}
// 对于外部库中的方法，必须使用unsafe代码块包裹
println!("Absolute value of -99999 according to C: {}", unsafe {
abs(-99999)
});
static mut VERSION: u8 = 12_u8;
unsafe { VERSION = 13 };
}
/// 创建裸指针
fn create_raw_point() {
let mut age = 30;
// 基于值的引用创建不可变和可变引用
let raw_point1 = &age as *const i32;
let raw_point2 = &mut age as *mut i32;
println!("raw point1 value:{}", unsafe { *raw_point1 });
println!("raw point2 value:{}", unsafe { *raw_point2 });
}
/// 凭空捏造一个内存地址作为裸指针
fn random_mem_addr_as_raw_pointer() {
let addr = 100000;
let raw_pointer = addr as *mut i32;
// 修改内存地址100001地址处的值
unsafe {
*raw_pointer = 123;
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/函数式编程/src/main.rs | rust基础/函数式编程/src/main.rs | use core::num;
fn main() {
// 定义闭包
// 判断是否为奇数
let is_odd_number = |num: u32| num % 2 != 0;
let a = 10;
let b = 11;
// 像普通函数一样使用
println!(
"a is odd number:{} b is odd number:{}",
is_odd_number(a),
is_odd_number(b)
);
// 闭包体捕获外部变量
let base = 11;
let add = |x: i32| x + base;
let result = add(9);
println!("add result:{result} ");
let base = 12;
// 使用move关键字，强制移动外部变量到闭包体中
let add = move |x: i32| {
// 打印此内存地址
println!("base addr:{:p}", &base);
x + base
};
let result = add(18);
// 下面不会报错，因为基础变量实现了Copy语义，栈上复制
// 从打印出的内存地址上可以验证这一点
println!("add result:{result} base:{base} base addr:{:p}", &base);
// 闭包作为函数参数
let closure_1 = |a: i32, b: i32| -> i32 { a + b };
fn test_closure_1(a: i32, b: i32, closure: impl Fn(i32, i32) -> i32) -> i32 {
closure(a, b)
}
let a = 123;
let b = 234;
let c = test_closure_1(a, b, closure_1);
println!("123+234={c}");
// 闭包作为函数返回值
fn return_closure(a: i32) -> impl Fn(i32) -> i32 {
move |x: i32| a * x
}
let a = 10;
let closure = return_closure(a);
let result = closure(100);
println!("10 * 100 ={result}");
// 闭包中的生命周期
// 编译错误
//let closure = |x:&i32|->&i32{x};
// 使用Fn
fn fn_closure<T, F: Fn(&T) -> &T>(f: F) -> F {
f
}
let closure = fn_closure(|x: &i32| -> &i32 { x });
println!("fn result:{}", closure(&32));
// 迭代器
let mut nums = vec![1, 2, 3, 4, 3, 2, 1, 3, 4, 5, 99];
// iter不改变值且可重入
for num in nums.iter() {
println!("num:{num}");
}
// iter_mut可改变值且可重入
for num in nums.iter_mut() {
*num += 10;
// 可以再次使用
println!("num:{num}");
}
// into_iter不可改变值且不可重入
for num in nums.into_iter() {
// 编译报错,不可修改
//*num += 1;
println!("num:{num}");
}
// 编译报错，nums不可在使用，nums被into_iter消费掉了
//println!("{:?}",nums);
// 函数式编程
let nums = vec![1,4,5,13,15,45,90,99];
let result = nums.iter().filter(|&num|num%3==0 && num%5==0).sum::<i32>();
println!("result:{result}");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/复合数据类型/src/main.rs | rust基础/复合数据类型/src/main.rs | use std::any::Any;
fn main() {
// 元组
// 定义一个元组
let tuple1 = ();
println!("tuple1:{:?}", tuple1);
// 定义一个拥有相同数据类型的元组
let tuple2 = (2, 4, 6, 8, 10);
println!("tuple2:{:?}", tuple2);
// 定义一个拥有不同数据类型的元组
let tuple3 = (1, 3.14, 9877_u32, 87658.9878_f64, true, '😄');
println!("tuple3:{:?}", tuple3);
// 通过下标获取元组值
println!("tuple3 第六个元素{:?}", tuple3.5);
// 通过解构方式获取元组值
let (a, b, c, d, e, f) = tuple3;
println!("第一个元素：{:?} 第二个元素:{:?} 第三个元素:{:?} 第四个元素:{:?} 第五个元素:{:?} 第六个元素:{:?}",a,b,c,d,e,f);
let result: () = no_return_function();
println!("result:{:?}", result);
let result1: i32 = have_return_function();
println!("result1:{}", result1);
// 数组，在栈上创建，大小不可变
let mut array1 = [1, 2, 3, 4, 5];
println!("array1 size:{}", array1.len());
// 使用vec!宏创建堆上可变大小的数组
let mut array2 = vec![2, 3, 4, 5, 5, 6, 7];
println!("array2 :{:?}", array2);
array2.push(9999);
println!("array2 :{:?}", array2);
// 使用Vec的关联函数
let mut array3 = Vec::new();
array3.push(99);
array3.push(88);
array3.push(77);
println!("array3 :{:?}", array3);
// 结构体
// 通过过程宏实现Debug特征，便于使用println！打印输出
#[derive(Debug)]
struct Student {
age: i32,
score: u32,
}
// impl块实现关联函数和方法
impl Student {
// 关联函数,返回Self表示Student实例
fn new(age: i32, score: u32) -> Self {
Student {
age: age,
score: score,
}
}
// 第一个参数为self，注意和关联函数返回值Self的区别，小写self表示类型，大写Self表示实例
fn get_age(&self) -> i32 {
self.age
}
}
// 结构体可以实现多个impl块
impl Student {
fn get_score(&self) -> u32 {
self.score
}
}
let student = Student::new(25, 140);
// 实现了Debug特征，可以:?的方式输出
println!(
"age:{} , score:{}, student:{:?}",
student.age, student.score, student
);
// 为Student实现Sing特征
impl Sing for Student {
fn sing(&self) {
println!("唱歌:dou ri mi fa sou la xi do.....");
}
}
// 调用sing方法
student.sing();
// 枚举
let action = Action::JUMP { height: 2.12_f64 };
do_action(&action);
println!("action:{:?}", &action);
let action = Action::QUIT;
println!("action:{:?}", &action);
do_action(&action);
action.say_hello("Rust");
action.sing();
// 切片
let s = String::from("hello world");
let hello = &s[..5];
let world = &s[6..11];
println!("{hello} -- {world}");
// 索引从0开始的两种写法
let s = String::from("rust");
let slice = &s[0..2];
println!("{slice}");
let slice = &s[..2];
println!("{slice}");
// 索引到最后一个字符的写法
let s = String::from("rust");
let len = s.len();
let slice = &s[2..len];
println!("{slice}");
let slice = &s[2..];
println!("{slice}");
// 索引必须落在UTF-8编码字符的边界，否则会报错退出
let s = "中国人";
//let a = &s[0..2];
//println!("{a}");
// 在数组中使用切片
let array = [2, 4, 6, 8, 10, 3, 6, 9];
println!("array slice:{:?}", &array[2..]);
println!("array slice:{:?}", &array[..5]);
// 复合类型数据转换
from_and_into_trait();
}
// 隐式返回()
fn no_return_function() {
println!("没有显式返回值的函数，隐式返回()");
}
// 表达式返回
fn have_return_function() -> i32 {
// 可以使用return关键字返回，如:return 8+9
// 推荐使用表达式返回
8 + 9
}
trait Sing {
fn sing(&self) {
println!("唱歌...")
}
}
#[derive(Debug)]
enum Action {
QUIT,
RUN { speed: i32, direction: u8 },
JUMP { height: f64 },
}
// 为枚举实现方法
impl Action {
fn say_hello(&self, name: &str) {
println!("say hello,{name}");
}
}
// 为枚举实现特征
impl Sing for Action {
fn sing(&self) {
println!("i'am action,i can sing,啦啦啦啦啦.....");
}
}
// 传入枚举进行模式匹配
fn do_action(action: &Action) {
if let Action::QUIT = action {
println!("退出....");
return;
}
// 使用match进行模式匹配
match action {
Action::JUMP { height } => {
println!("跳跃{}米", height)
}
Action::RUN { speed, direction } => {
println!("跑，速度:{}m/s , 方向:{}", speed, direction)
}
Action::QUIT => {
println!("退出....")
}
}
}
// From和Into两个Trait的演示用例
fn from_and_into_trait() {
// 动物
#[derive(Debug)]
struct Animal {
age: u32,
}
// 龙
#[derive(Debug)]
struct Loong {
age: u32,
}
impl From<Animal> for Loong {
fn from(value: Animal) -> Self {
Loong { age: value.age }
}
}
impl Into<Animal> for Loong {
fn into(self) -> Animal {
Animal { age: self.age }
}
}
let loong = Loong { age: 10000 };
println!("中国龙:{:?}", loong);
let loong_is_a_animal: Animal = loong.into();
println!("animal:{:?}", loong_is_a_animal);
let animal = Animal { age: 9999 };
let loong = Loong::from(animal);
println!("loong:{:?}", loong);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/宏/src/main.rs | rust基础/宏/src/main.rs | macro_rules! sum_all {
($($arg:expr),*) => {
{
let mut sum = 0;
$(sum +=$arg;)*
sum
}
};
}
fn main() {
let result = sum_all!(1, 2, 3, 4, 5);
println!("The sum is: {}", result); // 输出: The sum is: 15
let result = sum_all!(1, 2, 3, 4, 5, 6, 7, 8, 9);
println!("The sum is: {}", result); // 输出: The sum is: 45
let result = {
let mut num = 0;
num += 1;
num += 2;
num += 3;
num += 4;
num += 5;
num
};
println!("result:{result}");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/特征/src/main.rs | rust基础/特征/src/main.rs | use std::{
fmt::{Debug, Display},
ops::Add,
};
fn main() {
// 定义特征
// 为类型实现特征
let tiger = Tiger::new(3, "OldSix");
tiger.behavior();
// 结构体方法传入特征
tiger.show(&tiger);
// 结构体方法返回特征
let action = tiger.do_action();
action.eat();
// 打破孤儿规则
struct MyString(String);
impl Display for MyString {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let display_str = String::from("---->") + &self.0 + &String::from("<----");
f.write_str(display_str.as_str())
}
}
let my_string = MyString(String::from("我是newtype"));
println!("{my_string}");
// 函数传递特征参数
fn show_my_string(my_string: &impl Display) {
println!("{my_string}");
}
show_my_string(&my_string);
// 泛型约束，定义say_hello泛型方法
// 使用Action+Debug+Clone+PartialOrd+PartialEq多重特征约束
fn say_hello<T: Action + Debug + Clone + PartialOrd + PartialEq>(item: &T) {
println!("----开始展示----");
item.eat();
item.wearing();
item.living();
item.walk();
println!("{:?}", item);
}
// 使用where字句改写
fn say_hello1<T>(item: &T)
where
T: Action + Debug + Clone + PartialOrd + PartialEq,
{
println!("----开始展示----");
item.eat();
item.wearing();
item.living();
item.walk();
println!("{:?}", item);
}
say_hello(&tiger);
say_hello1(&tiger);
// 函数返回特征
fn do_action() -> impl Action + Debug + Clone + PartialEq + PartialOrd {
Tiger::new(20, "OldSixSix")
}
let action = do_action();
action.eat();
// 定义函数，接收一个参数
// 函数体根据参数，决定返回哪个实现了Action的实例
// 下面代码编译报错
// fn do_action_with_arg(label: u8) -> impl Action {
// if label == 1 {
// Tiger::new(3, "OldSix")
// } else {
// Whale::new(60, "Tom")
// }
// }
// 使用特征对象改进
fn do_action_with_arg(label: u8) -> Box<dyn Action> {
if label == 1 {
Box::new(Tiger::new(3, "OldSix"))
} else {
Box::new(Whale::new(60, "Tom"))
}
}
let action1 = do_action_with_arg(1);
let action2 = do_action_with_arg(2);
action1.eat();
action2.eat();
// 特征中的关联类型
let mut list = List {
datas: vec![1, 4, 6, 8, 9],
};
let next_value = list.next();
println!("next_value:{:?} list:{:?}", next_value, list);
// 特征中使用泛型
let msg = Message {
msg: String::from("学习rust,2024拿下rust"),
};
msg.printf(String::from(" 拥抱未来语言Rust "));
// 特征中为泛型指定默认类型
let point_a = Point { x: 34, y: 56 };
let point_b = Point { x: 98, y: 108 };
let point_c = point_a.sum(point_b);
// 下面打印报错，具体涉及到所有权知识点，后面章节详细介绍
//println!("point_a:{:?} + point_b:{:?} = point_c:{:?}",point_a, point_b, point_c);
println!("point_c:{:?}", point_c);
// 特征约束
let human = Human::new(175.12, 75.01);
human.behavior();
}
/// 定义Action特征
trait Action {
// 吃
fn eat(&self);
// 穿
// 可以提供默认实现
fn wearing(&self) {
println!("我穿皮毛....");
}
// 住
fn living(&self);
// 行
fn walk(&self);
}
#[derive(Debug, Clone, PartialOrd, PartialEq)]
struct Tiger {
age: u32,
name: String,
}
impl Action for Tiger {
fn eat(&self) {
println!("我吃肉...特别喜欢鹿肉哦.")
}
fn living(&self) {
println!("我住山洞，冬暖夏凉.")
}
fn walk(&self) {
println!("我的四条火腿跑得贼快.")
}
}
struct Whale {
age: u32,
name: String,
}
impl Action for Whale {
fn eat(&self) {
println!("我吃磷虾.");
}
fn living(&self) {
println!("我住南太平洋.");
}
fn walk(&self) {
println!("我用尾巴当螺旋桨");
}
}
impl Whale {
fn new(age: u32, name: &str) -> Self {
Self {
age: age,
name: String::from(name),
}
}
}
impl Tiger {
fn new(age: u32, name: &str) -> Self {
Self {
age: age,
name: String::from(name),
}
}
fn behavior(&self) {
println!("大家好,我今年{}岁,我叫:{}", self.age, self.name);
self.eat();
self.wearing();
self.living();
self.walk();
}
// 方法中传递特征
fn show(&self, action: &impl Action) {
action.eat();
}
// 方法返回特征
fn do_action(&self) -> impl Action + Debug + Clone + PartialEq + PartialOrd {
Self {
age: self.age,
name: String::from(self.name.as_str()),
}
}
}
/// 在特征中使用特征约束
/// 实现HumanAction必须先实现Action特征
trait HumanAction: Action {
fn typing(&self) {
println!("我会码字...")
}
}
struct Human {
height: f32,
weight: f32,
}
impl Action for Human {
fn eat(&self) {
println!("我吃得健康，必须荤素搭配.");
}
fn living(&self) {
println!("我住钢筋水泥..");
}
fn walk(&self) {
println!("我出行开发，坐飞机，坐火车都行..");
}
fn wearing(&self) {
println!("我穿棉衣");
}
}
impl HumanAction for Human {
fn typing(&self) {
println!("我靠码字养活自己.");
}
}
impl Human {
fn new(height: f32, weight: f32) -> Self {
Self { height, weight }
}
fn behavior(&self) {
println!("大家好,我身高{}cm,我体重:{}公斤", self.height, self.weight);
self.eat();
self.wearing();
self.living();
self.walk();
}
}
/// 关联类型
trait Iterator {
// 使用关键字type定义的关联类型
// 是一个占位符，此时还未有具体的类型
type Item;
fn next(&mut self) -> Option<Self::Item>;
}
#[derive(Debug)]
struct List {
datas: Vec<i32>,
}
impl Iterator for List {
type Item = i32;
// 倒序遍历
fn next(&mut self) -> Option<Self::Item> {
self.datas.pop()
}
}
// 特征中使用泛型并带默认泛型类型
// 默认泛型类型使用=号指定，这里指Self类型
// 即实现了Sum特征的类型
trait Sum<T = Self> {
// 定义关联类型，是一个占位符
// 该占位符由具体的结构体指定
// 用于指定方法返回结果类型
type Output;
fn sum(&self, other: T) -> Self::Output;
}
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
impl Sum for Point {
// 关联类型指定为Point类型
// 即sum函数的返回类型为Point
type Output = Point;
// 由于默认泛化类型是Self
// 在Point结构体中就指Point类型
// 因此在sum函数中T使用Point
fn sum(&self, other: Point) -> Point {
Self {
x: self.x + other.x,
y: self.y + other.y,
}
}
}
// 在特征中使用泛型
trait Print<T: Debug> {
fn printf(&self, data: T);
}
struct Message {
msg: String,
}
impl<T: Debug> Print<T> for Message {
fn printf(&self, data: T) {
println!("self message:{} , data:{:?}", self.msg, data);
}
}
impl Message {
fn new(msg: String) -> Self {
Self { msg: msg }
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/点操作符的魔力/src/bin/magic_of_point.rs | rust基础/点操作符的魔力/src/bin/magic_of_point.rs | use std::rc::Rc;
fn main() {
let array: Rc<Box<[i32; 10]>> = Rc::new(Box::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 0]));
let first_element = array.get(0);
println!("first element:{:?}", first_element);
let mut rc = Rc::new(10);
let rc1 = &rc;
let mut rc1 = &mut rc;
let array1 = array.clone();
//let sandbox = *array1;
let mut Box = Box::new(1);
let a = [1, 2, 3, 4];
let result = a.get(0);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/并发和并行/src/bin/once_init.rs | rust基础/并发和并行/src/bin/once_init.rs | use std::{sync::Once, thread, time::Duration};
fn main() {
static mut VERSION: &str = "1.2.3";
static INIT: Once = Once::new();
let handle1 = thread::spawn(move || {
//thread::sleep(Duration::from_millis(10));
INIT.call_once(|| unsafe {
VERSION = "1.2.5";
});
});
let handle2 = thread::spawn(move || {
//thread::sleep(Duration::from_millis(10));
INIT.call_once(|| unsafe {
VERSION = "1.2.6";
});
});
handle1.join().unwrap();
handle2.join().unwrap();
println!("VERSION:{}", unsafe { VERSION });
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/并发和并行/src/bin/move_ownership.rs | rust基础/并发和并行/src/bin/move_ownership.rs | use std::{thread, time::Duration};
fn main() {
let hello = String::from("Hello Rust");
let handle = thread::spawn(move || {
// 线程睡眠1000毫秒
thread::sleep(Duration::from_millis(1000));
// 打印出当前线程id
println!("{} , thread_id:{:?}", hello, thread::current().id());
});
handle.join().unwrap();
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/并发和并行/src/bin/condition_var_and_mutex.rs | rust基础/并发和并行/src/bin/condition_var_and_mutex.rs | use std::borrow::Borrow;
use std::sync::{Arc, Condvar, Mutex};
use std::thread;
use std::time::Duration;
fn main() {
let pair = Arc::new((Mutex::new(false), Condvar::new()));
let pair2 = pair.clone();
println!("main 锁定的值为:{:?}", pair.0.lock().unwrap());
thread::spawn(move || {
let (lock, cvar) = &*pair2;
let mut started = lock.lock().unwrap();
println!("子线程修改锁定的值为true");
*started = true;
// 通知等在该条件上的线程
cvar.notify_one();
});
//thread::sleep(Duration::from_millis(10));
let (lock, cvar) = &*pair;
let mut started = lock.lock().unwrap();
// main线程等待锁里面的值变为true
println!("main wait..");
started = cvar.wait(started).unwrap();
println!("main 线程 {started}");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/并发和并行/src/bin/thread_barrier.rs | rust基础/并发和并行/src/bin/thread_barrier.rs | use std::{
sync::{Arc, Barrier},
thread::{self, JoinHandle},
};
fn main() {
let cap: usize = 11;
let mut handles: Vec<JoinHandle<()>> = Vec::with_capacity(cap);
// 通过Arc在堆上创建多线程安全且共享所有权的Barrier，屏障初始为11个线程
let barrier: Arc<Barrier> = Arc::new(Barrier::new(cap));
for i in 0..=10 {
// clone增加引用计数
let b: Arc<Barrier> = barrier.clone();
handles.push(thread::spawn(move || {
println!("thread {i} before wait");
// 屏障等待
b.wait();
println!("thread {i} after wait");
}));
}
for handle in handles {
handle.join().unwrap();
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/并发和并行/src/bin/wait_child_thread.rs | rust基础/并发和并行/src/bin/wait_child_thread.rs | use std::{thread, time::Duration};
fn main() {
let handle = thread::spawn(|| {
// 线程睡眠1000毫秒
thread::sleep(Duration::from_millis(1000));
// 打印出当前线程id
println!(
"Hello Rust from thread , thread_id:{:?}",
thread::current().id()
);
});
// 主线程打印出当前线程id
println!(
"Hello Rust from main thread , thread_id:{:?}",
thread::current().id()
);
// 调用子线程返回的句柄上的join方法
// 会使父线程阻塞，直到它等待的子线程结束
handle.join().unwrap();
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/并发和并行/src/bin/thread_local.rs | rust基础/并发和并行/src/bin/thread_local.rs | use std::cell::Cell;
use std::sync::Arc;
use std::thread;
use std::time::Duration;
use thread_local::ThreadLocal;
fn main() {
// 使用标准库中的thread_local!宏创建线程局部变量
// 使用Cell提供内部可变性
thread_local! { static INIT:Cell<i32> = Cell::new(100)};
INIT.with(|i| {
println!("main thread i={}", i.get());
i.set(i.get() - 1);
println!("main thread i={}", i.get());
});
println!("main thread INIT VALUE:{}", INIT.get());
// 在线程中使用线程局部变量
let handle = thread::spawn(move || {
INIT.with(|i| {
println!("child thread i={}", i.get());
i.set(i.get() - 100);
println!("child thread i={}", i.get());
});
});
handle.join().unwrap();
println!("main thread INIT VALUE:{}", INIT.get());
// 在结构体中使用线程局部变量
struct Task;
impl Task {
thread_local! { static INIT:Cell<i32> = Cell::new(100)}
fn set_init(&self, num: i32) {
INIT.set(num);
}
fn get_init(&self) -> i32 {
INIT.get()
}
}
let task = Task;
task.set_init(1000);
println!("main thread struct INIT:{}", task.get_init());
let handle = thread::spawn(move || {
task.set_init(99);
println!("child thread struct INIT:{}", task.get_init());
});
handle.join().unwrap();
// 下面编译错误，因为task所有权已经移动到了子线程中
// println!("main thread struct INIT:{}", task.get_init());
// 使用第三方库thread_local创建本地变量
// Arc在多个线程间安全的共享所有权
let tl = Arc::new(ThreadLocal::new());
// 主线程中初始化为99
tl.get_or(|| Cell::new(99));
let mut handles = vec![];
// 创建多个线程
for _i in 0..=4 {
let tl_i = tl.clone();
let handle = thread::spawn(move || {
let cell = tl_i.get_or(|| Cell::new(100));
cell.set(cell.get() + 1);
});
handles.push(handle);
}
println!("引用计数:{}", Arc::strong_count(&tl));
for handle in handles {
handle.join().unwrap();
}
println!("引用计数:{}", Arc::strong_count(&tl));
println!("main thread tl:{}", tl.get().unwrap().get());
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/并发和并行/src/bin/first_thread.rs | rust基础/并发和并行/src/bin/first_thread.rs | use std::{thread, time::Duration};
fn main() {
thread::spawn(|| {
// 线程睡眠1000毫秒
thread::sleep(Duration::from_millis(1000));
// 打印出当前线程id
println!(
"Hello Rust from thread , thread_id:{:?}",
thread::current().id()
);
});
// 主线程打印出当前线程id
println!(
"Hello Rust from main thread , thread_id:{:?}",
thread::current().id()
);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/auto_test/src/lib.rs | rust基础/auto_test/src/lib.rs | /// 判断一个数是否为奇数
fn odd_number(a: usize) -> bool {
let mut result = true;
if a % 2 == 0 {
result = false
};
result
}
/// 判断一个数是否是偶数
fn even_number(a: usize) -> bool {
!odd_number(a)
}
/// 判断一个数是否能被5整除
/// `````
/// let a = 125_usize;
/// let r = auto_test::devide_by_5(a);
/// assert_eq!(r,true);
/// `````
pub fn devide_by_5(a: usize) -> bool {
if a % 5 == 0 {
true
} else {
false
}
}
/// 通过右移操作除以2
pub fn devide_2(a: isize) -> isize {
a >> 1
}
#[cfg(test)]
mod tests {
use crate::*;
#[test]
fn test_odd_number() {
let num = 125;
assert!(odd_number(num));
}
#[test]
fn test_even_number() {
let num = 124;
assert!(even_number(num));
}
// 通过#[ignore忽略该测试]
#[test]
#[ignore]
fn test_even_number2() {
let num = 125;
assert!(even_number(num), "你输入的数:{}不是偶数", num);
}
// 使用pretty_assertion中的assert_eq断言
#[test]
fn prettry_assertion() {
use pretty_assertions::assert_eq;
assert_eq!(1 + 1, 3);
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/auto_test/src/main.rs | rust基础/auto_test/src/main.rs | fn main(){
let a = 3;
let b = 1 + 3;
debug_assert_eq!(a, b, "我们在测试两个数之和{} + {}，这是额外的错误信息", a, b);
} | rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/auto_test/tests/integration_test1.rs | rust基础/auto_test/tests/integration_test1.rs | use auto_test;
#[test]
fn test_devide_by_5() {
assert_eq!(auto_test::devide_by_5(555), true);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/auto_test/benches/benchmark_test1.rs | rust基础/auto_test/benches/benchmark_test1.rs | use criterion::{black_box, criterion_group, criterion_main, Criterion};
fn pow_5(num:i32)->i32{
num * num * num * num * num
}
fn criterion_benchmark(c: &mut Criterion) {
c.bench_function("pow_5", |b| b.iter(|| pow_5(black_box(100))));
}
criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/async_programming/src/lib.rs | rust基础/async_programming/src/lib.rs | use std::{
future::Future,
pin::Pin,
sync::{Arc, Mutex},
task::{Context, Poll, Waker},
thread,
time::Duration,
};
pub struct TimerFuture {
shared_state: Arc<Mutex<SharedState>>,
}
/// 在Future和等待的线程间共享状态
struct SharedState {
completed: bool,
waker: Option<Waker>,
}
impl Future for TimerFuture {
type Output = ();
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
let mut shared_state = self.shared_state.lock().unwrap();
if shared_state.completed {
Poll::Ready(())
} else {
shared_state.waker = Some(cx.waker().clone());
Poll::Pending
}
}
}
impl TimerFuture {
/// 创建一个新的`TimerFuture`，在指定的时间结束后，该`Future`可以完成
pub fn new(duration: Duration) -> Self {
let shared_state = Arc::new(Mutex::new(SharedState {
completed: false,
waker: None,
}));
// 创建新线程
let thread_shared_state = shared_state.clone();
thread::spawn(move || {
thread::sleep(duration);
let mut shared_state = thread_shared_state.lock().unwrap();
shared_state.completed = true;
if let Some(waker) = shared_state.waker.take() {
waker.wake()
}
});
TimerFuture { shared_state }
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/async_programming/src/main.rs | rust基础/async_programming/src/main.rs | use {
// 引入之前实现的定时器模块
async_programming::TimerFuture,
futures::{
future::{BoxFuture, FutureExt},
task::{waker_ref, ArcWake},
},
std::{
future::Future,
sync::mpsc::{sync_channel, Receiver, SyncSender},
sync::{Arc, Mutex},
task::Context,
time::Duration,
},
};
/// 任务执行器，负责从通道中接收任务然后执行
struct Executor {
ready_queue: Receiver<Arc<Task>>,
}
/// `Spawner`负责创建新的`Future`然后将它发送到任务通道中
#[derive(Clone)]
struct Spawner {
task_sender: SyncSender<Arc<Task>>,
}
/// 一个Future，它可以调度自己(将自己放入任务通道中)，然后等待执行器去`poll`
struct Task {
/// 进行中的Future，在未来的某个时间点会被完成
future: Mutex<Option<BoxFuture<'static, ()>>>,
/// 可以将该任务自身放回到任务通道中，等待执行器的poll
task_sender: SyncSender<Arc<Task>>,
}
fn new_executor_and_spawner() -> (Executor, Spawner) {
const MAX_QUEUED_TASKS: usize = 10_000;
let (task_sender, ready_queue) = sync_channel(MAX_QUEUED_TASKS);
(Executor { ready_queue }, Spawner { task_sender })
}
impl Spawner {
fn spawn(&self, future: impl Future<Output = ()> + 'static + Send) {
let future = future.boxed();
let task = Arc::new(Task {
future: Mutex::new(Some(future)),
task_sender: self.task_sender.clone(),
});
self.task_sender.send(task).expect("任务队列已满");
}
}
impl ArcWake for Task {
fn wake_by_ref(arc_self: &Arc<Self>) {
let cloned = arc_self.clone();
arc_self.task_sender.send(cloned).expect("任务队列已满");
}
}
impl Executor {
fn run(&self) {
while let Ok(task) = self.ready_queue.recv() {
let mut future_slot = task.future.lock().unwrap();
if let Some(mut future) = future_slot.take() {
let waker = waker_ref(&task);
let context = &mut Context::from_waker(&*waker);
if future.as_mut().poll(context).is_pending() {
*future_slot = Some(future);
}
}
}
}
}
fn main() {
let (executor, spawner) = new_executor_and_spawner();
async fn hello(){
println!("hello world");
}
spawner.spawn(async {
println!("howdy!");
//TimerFuture::new(Duration::new(2, 0)).await;
hello().await;
println!("done!");
});
drop(spawner);
// 任务运行后，会先打印`howdy!`, 暂停2秒，接着打印 `done!`
executor.run();
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/async_programming/src/bin/async_join.rs | rust基础/async_programming/src/bin/async_join.rs | use futures::{executor::block_on, FutureExt};
/// join并发的执行多个Future
fn main() {
// 使用异步的方式计算(1+1)*(2+2)
async fn one_add_one() -> i32 {
1 + 1
}
async fn two_add_two() -> i32 {
2 + 2
}
async fn part_mult_part() -> i32 {
let f1 = one_add_one();
let f2 = two_add_two();
// 使用join!并发执行多个Future
let res = futures::join!(f1, f2);
res.0 * res.1
}
let result = block_on(part_mult_part());
println!("(1+1)*(2+2)={result}");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/async_programming/src/bin/async_hello_world.rs | rust基础/async_programming/src/bin/async_hello_world.rs | use futures::executor::block_on;
/// 异步编程的Hello world
fn main() {
// 使用async fn创建异步函数
async fn async_hi() {
println!("hello world from async");
}
// 调用async_hi异步函数
let result = async_hi();
block_on(result);
async fn async_hello() {
println!("hello");
async_world().await;
}
async fn async_world() {
println!("world")
}
block_on(async_hello());
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/src/main.rs | rust基础/生产级别workspace/src/main.rs | fn main() {
println!("Hello, world!");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/services/printer/src/testx.rs | rust基础/生产级别workspace/crates/services/printer/src/testx.rs | pub fn testx(){
println!("testx");
} | rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/services/printer/src/main.rs | rust基础/生产级别workspace/crates/services/printer/src/main.rs | // 在包里面引用其它的包
use lib_core::core1::core1_test;
use lib_core::core2::core_test2;
use lib_core::core3::fn1::fn1;
use lib_core::core3::fn2::fn2;
use lib_utils::util1::util1;
use lib_utils::util2::util2;
// 使用as命名别名解决命名冲突
use lib_utils::utils3::fn1::fn1 as util_fn1;
use lib_utils::utils3::fn2::fn2 as util_fn2;
mod testx;
fn main() {
core1_test();
core_test2();
fn1();
fn2();
util1();
util2();
util_fn1();
util_fn2();
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-utils/src/lib.rs | rust基础/生产级别workspace/crates/libs/lib-utils/src/lib.rs | // 对外暴露模块
pub mod util1;
pub mod util2;
pub mod utils3;
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-utils/src/util1.rs | rust基础/生产级别workspace/crates/libs/lib-utils/src/util1.rs | pub fn util1() {
println!("lib-utils util1");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-utils/src/util2.rs | rust基础/生产级别workspace/crates/libs/lib-utils/src/util2.rs | pub fn util2() {
println!("lib-utils util2");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-utils/src/utils3/fn2.rs | rust基础/生产级别workspace/crates/libs/lib-utils/src/utils3/fn2.rs | pub fn fn2() {
println!("lib-utils util3 fn2");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-utils/src/utils3/fn1.rs | rust基础/生产级别workspace/crates/libs/lib-utils/src/utils3/fn1.rs | pub fn fn1() {
println!("lib-utils util3 fn1");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-utils/src/utils3/mod.rs | rust基础/生产级别workspace/crates/libs/lib-utils/src/utils3/mod.rs | pub mod fn1;
pub mod fn2;
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-core/src/core2.rs | rust基础/生产级别workspace/crates/libs/lib-core/src/core2.rs | pub fn core_test2() {
println!("lib-core core2 core_test2")
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-core/src/lib.rs | rust基础/生产级别workspace/crates/libs/lib-core/src/lib.rs | // 对外暴露模块
pub mod core1;
pub mod core2;
pub mod core3;
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-core/src/core1.rs | rust基础/生产级别workspace/crates/libs/lib-core/src/core1.rs | // pub关键字将模块暴露给外面使用
pub fn core1_test() {
println!("lib-core core1 core1_test")
}
// 这个方法在该模块外无法访问到
fn core1_test1() {
println!("lib-core core1 core1_test1")
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-core/src/core3/fn2.rs | rust基础/生产级别workspace/crates/libs/lib-core/src/core3/fn2.rs | pub fn fn2() {
println!("lib-core core3 fn2");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-core/src/core3/fn1.rs | rust基础/生产级别workspace/crates/libs/lib-core/src/core3/fn1.rs | pub fn fn1() {
println!("lib-core core3 fn1");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/生产级别workspace/crates/libs/lib-core/src/core3/mod.rs | rust基础/生产级别workspace/crates/libs/lib-core/src/core3/mod.rs | // 对外暴露fn1和fn2
pub mod fn1;
pub mod fn2;
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/类型别名/src/main.rs | rust基础/类型别名/src/main.rs |
fn main() {
type Hour = u8;
type Minute = u8;
let a: u8 = 23;
let hour: Hour = 23;
println!("a == hour : {}", a == hour);
let b: u8 = 59;
let minute: Minute = 59;
println!("b == minute : {}", b == minute);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/认识变量常量和标量/src/main.rs | rust基础/认识变量常量和标量/src/main.rs | // 包级别静态变量，不允许遮盖
static mut AGE: i32 = 30;
// 遮盖报错
//static mut AGE:i32 = 30;
fn main() {
// 不会被使用到的变量，使用_开头来定义
let _age: i32 = 33;
// 编译报错，不可变变量不能改变值
//age = 31;
let mut height: i32 = 175;
// 可变变量可以重新绑定值，重新绑定后位于栈中的175将被自动释放掉
height -= 5;
println!("height:{height}");
// 可以使用let覆盖之前定义过的同名变量
let mut height: i32 = 185;
height += 5;
println!("一个美男子,身高:{height}");
unsafe {
println!("静态变量age:{AGE}");
AGE += 3;
println!("静态变量age:{AGE}");
static mut AGE: i32 = 35;
// 方法级别静态变量，不允许遮盖,不允许修改
static SCORES: i32 = 88;
// 遮盖报错
//static SCORES:i32 = 99;
println!("Scores:{SCORES}");
// 允许修改，不允许遮盖
static mut MINUTES: i32 = 50;
MINUTES += 10;
println!("MINUTES:{MINUTES}");
}
// 由于不能修改，定义时不能使用mut关键字修饰
const HADOOP_HOME: &str = "/data/softwares/hadoop-3.2.2";
// 不可修改
//HADOOP_HOME = "/data/softwares/hadoop-3.2.1";
// 不能遮盖
//const HADOOP_HOME:&str = "/data/softwares/hadoop-3.3.3";
println!("HADOOP HOME:{HADOOP_HOME}");
// 整数的具体类型
let a: i32 = 123_456_789;
let b = 123_789_u32;
let c = 9879768723usize;
println!("a:{a} b:{b} c:{c}");
// 浮点数
let weight = 73.5_f64;
let height = 172.5_f32;
println!("weight:{weight},height:{height}");
// 布尔值
let _pass: bool = true;
// 字符
let smile: char = '😄';
let dog_head: char = '🐶';
println!("smile : {smile} , dog_head : {dog_head}");
// 类型转换
let bool_to_u32 = _pass as u32;
let char_to_u32 = smile as u32;
let f64_to_u32 = weight as u32;
let i32_to_f64 = c as f64;
println!("bool to u32:{bool_to_u32} \n char to u32 :{char_to_u32} \n f64 to u32 :{f64_to_u32} \n i32 to f64:{i32_to_f64}\n");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/rc_not_safe.rs | rust基础/线程同步和线程安全/src/bin/rc_not_safe.rs | use std::{rc::Rc, sync::Arc, thread};
/// 在线程中使用Rc智能指针
fn main() {
let _t = Rc::new(100);
Arc::new(10);
let handler = thread::spawn(move || {
// 下面打印会报错
// println!("t:{:?}", t);
});
handler.join().unwrap();
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/mpsc_multi.rs | rust基础/线程同步和线程安全/src/bin/mpsc_multi.rs | use std::{sync::mpsc, thread};
fn main() {
// 创建一个通道，返回元组(发送者，接收者)
let (sender, receiver) = mpsc::channel();
// 克隆一个生产者
let sender1 = sender.clone();
// 生产者1
thread::spawn(move || {
let thread_id = thread::current().id();
let msg = format!("加油2024 来自线程:{:?}", thread_id);
let _ = sender.send(msg);
});
// 生产者2
thread::spawn(move || {
let thread_id = thread::current().id();
let msg = format!("加油2024 来自线程:{:?}", thread_id);
let _ = sender1.send(msg);
});
// 在主线程中使用for循环接收消息
for msg in receiver {
println!("收到消息：{msg}");
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/atomic_and_mutex.rs | rust基础/线程同步和线程安全/src/bin/atomic_and_mutex.rs | use std::ops::Sub;
use std::{
sync::{
atomic::{AtomicU32, Ordering},
Arc, Mutex,
},
thread::{self, JoinHandle},
time::Instant,
};
// 使用Atomic和Mutex做比较
fn main() {
// 原子类型作为全局变量
const N_TIMES: u32 = 1000000;
const CAP: usize = 100;
static RESULT: AtomicU32 = AtomicU32::new(0);
fn add_n_times(n: u32) -> JoinHandle<()> {
thread::spawn(move || {
for _ in 1..=n {
RESULT.fetch_add(1, Ordering::Relaxed);
}
})
}
fn add_n_times_2(n: u32, lock: Arc<Mutex<i32>>) -> JoinHandle<()> {
thread::spawn(move || {
let mut num = lock.lock().unwrap();
for _ in 1..=n {
*num += 1;
}
})
}
let start_time = Instant::now();
let mut handles = Vec::with_capacity(CAP);
for _ in 1..=CAP {
handles.push(add_n_times(N_TIMES));
}
for handle in handles {
handle.join().unwrap();
}
println!("{:?}", RESULT.load(Ordering::Relaxed));
println!("原子变量耗时:{:?}", Instant::now().sub(start_time));
// 使用Mutex
let start_time = Instant::now();
let mutex = Arc::new(Mutex::new(0));
let mut handles = Vec::with_capacity(CAP);
for _ in 1..=CAP {
let m = mutex.clone();
handles.push(add_n_times_2(N_TIMES, m));
}
for handle in handles {
handle.join().unwrap();
}
println!("{:?}", *mutex);
println!("Mutex耗时:{:?}", Instant::now().sub(start_time));
// 内部可变性
show_change();
}
// Atomic和Mutex的值具有内部可变性
fn show_change() {
let lock1 = Mutex::new(10);
// 修改内部值
*lock1.lock().unwrap() += 10;
let lock2 = AtomicU32::new(10);
let before_value = lock2.fetch_add(10, Ordering::Relaxed);
println!(
"before value:{before_value} current value:{:?}",
lock2.load(Ordering::Relaxed)
);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/for_mpsc.rs | rust基础/线程同步和线程安全/src/bin/for_mpsc.rs | use std::{sync::mpsc, thread, time::Duration};
fn main() {
// 创建一个通道，返回元组(发送者，接收者)
let (sender, receiver) = mpsc::channel();
// 创建子线程向主线程发送消息
thread::spawn(move || {
for i in 1..=10 {
// 使用move将sender的所有权移动到子线程中
// send方法返回Result，因为能发送失败
// 这里直接unwrap取出Ok
let msg = String::from(format!("Message_{i}"));
let result = sender.send(msg);
// 编译报错，msg没有实现COPY特征，所有权被转移
//println!("msg ：{msg}");
if let Ok(()) = result {
println!("子线程发送消息成功");
} else {
println!("子线程发送消息失败");
}
thread::sleep(Duration::from_millis(1000));
}
});
// 在主线程中使用for循环接收消息
for msg in receiver {
println!("收到消息：{msg}");
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/mutex_in_multi_thread.rs | rust基础/线程同步和线程安全/src/bin/mutex_in_multi_thread.rs | use std::{
sync::{Arc, Mutex},
thread,
};
/// 多线程中使用Mutex
fn main() {
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
// 新建50个线程，每个线程对counter做加1操作
for _ in 1..=50 {
// 使用共享所有权且线程安全的智能指针Arc，如果使用Rc会报错
let counter = counter.clone();
let handle = thread::spawn(move || {
// 获得锁
let mut num = counter.lock().unwrap();
// 对锁住的值+1
*num += 1;
});
handles.push(handle);
}
// 等待所有线程结束
for handle in handles {
handle.join().unwrap();
}
// 打印counter中的数值
println!("counter:{}", *counter.lock().unwrap()); // 结果为50
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/mutex1.rs | rust基础/线程同步和线程安全/src/bin/mutex1.rs | use std::sync::Mutex;
fn main() {
// 使用Mutex创建互斥锁实例
let m = Mutex::new(10);
{
// lock方法获取MutexGuard
// MutexGuard实现了Deref特征和Drop特征
let mut lock: std::sync::MutexGuard<i32> = m.lock().unwrap();
// 通过*解引用获取值，并修改值
*lock = *lock - 1;
} // <--- num离开作用域时，自动调用drop释放锁
println!("m:{:?}", m);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/memory_order.rs | rust基础/线程同步和线程安全/src/bin/memory_order.rs | use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use std::{hint, thread};
fn main() {
let spinlock = Arc::new(AtomicUsize::new(1));
let spinlock_clone = Arc::clone(&spinlock);
let thread = thread::spawn(move || {
spinlock_clone.store(100, Ordering::Release); // 内存屏障1↑
});
// 等待其它线程释放锁
while spinlock.load(Ordering::Acquire) != 100 {
// 内存屏障2↓
// 自旋
hint::spin_loop();
}
thread.join().unwrap();
println!("spin lock:{:?}", spinlock);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/mutex_and_condvar.rs | rust基础/线程同步和线程安全/src/bin/mutex_and_condvar.rs | use std::{
sync::{Arc, Condvar, Mutex},
thread,
time::Duration,
};
/// mutex和condvar一起控制线程同步
fn main() {
// 在线程之间共享所有权
let lock = Arc::new(Mutex::new(false));
let con = Arc::new(Condvar::new());
let lock_1 = lock.clone();
let con_1 = con.clone();
let handle = thread::spawn(move || {
let mut locked = lock_1.lock().unwrap();
let mut counter = 0;
while counter < 3 {
// CondVar等待条件变为true，此时本线程阻塞
// CondVar的wait方法会释放Mutex上的锁，其它线程有机会获得锁
// 由其它的线程通知唤醒
locked = con_1.wait(locked).unwrap();
// 唤醒后立即将锁置为false
*locked = false;
counter += 1;
println!("子线程counter:{counter}");
}
});
let mut counter = 0;
loop {
thread::sleep(Duration::from_secs(1));
// 获取锁并置为true
*lock.lock().unwrap() = true;
counter += 1;
if counter > 3 {
break;
}
println!("主线程counter:{counter}");
// 通过条件通知其它线程
con.notify_one();
}
handle.join().unwrap();
println!("lock:{:?}", lock);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/dead_lock_by_mutex.rs | rust基础/线程同步和线程安全/src/bin/dead_lock_by_mutex.rs | use std::sync::Mutex;
fn main() {
// 使用Mutex创建互斥锁实例
let m = Mutex::new(10);
{
// lock方法获取MutexGuard
// MutexGuard实现了Deref特征和Drop特征
let mut lock: std::sync::MutexGuard<i32> = m.lock().unwrap();
// 通过*解引用获取值，并修改值
*lock = *lock - 1;
//drop(lock);
// 再次获取锁
let mut lock = m.lock().unwrap();
*lock = *lock + 1;
} // <--- num离开作用域时，自动调用drop释放锁
println!("m:{:?}", m);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/send_multi_type_data.rs | rust基础/线程同步和线程安全/src/bin/send_multi_type_data.rs | use std::{sync::mpsc, thread};
fn main() {
// 创建枚举
#[derive(Debug)]
enum Animal {
Dog(String, u8),
Cat(String, u8),
Fish(String, u8, f32),
}
let (sender, receiver) = mpsc::channel();
thread::spawn(move || {
let dog = Animal::Dog(String::from("憨憨"), 3);
let cat = Animal::Cat("胖丁儿".to_string(), 3);
let fish = Animal::Fish("鱼儿".to_string(), 1, 3.5);
sender.send(dog).unwrap();
sender.send(cat).unwrap();
sender.send(fish).unwrap();
});
// 在主线程中接收消息
for msg in receiver {
println!("{:?}", msg);
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/mpsc_single.rs | rust基础/线程同步和线程安全/src/bin/mpsc_single.rs | use std::{sync::mpsc, thread};
fn main() {
// 创建一个通道，返回元组(发送者，接收者)
let (sender, receiver) = mpsc::channel();
// 创建子线程向主线程发送消息
thread::spawn(move || {
// 使用move将sender的所有权移动到子线程中
// send方法返回Result，因为能发送失败
// 这里直接unwrap取出Ok
let result = sender.send("加油2024");
if let Ok(()) = result {
println!("子线程发送消息成功");
} else {
println!("子线程发送消息失败");
}
});
// 在主线程中接收消息
// recv会阻塞当前线程，直到有消息返回或者channel被关闭为止
let msg = receiver.recv();
if let Ok(msg) = msg {
println!("接收到子线程发送的消息:{msg}");
} else {
println!("接收消息失败...");
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/impl_send_for_pointer.rs | rust基础/线程同步和线程安全/src/bin/impl_send_for_pointer.rs | use std::thread;
/// 为裸指针实现Send特征
fn main() {
let num = 100;
let p = num as *mut i32;
let p = SandBox(p);
let handler = thread::spawn(move || {
println!("{:?}", p);
});
// 下面打印会报错，因为p的所有权已经被转移到子线程中去了
// println!("{:?}",p);
handler.join().unwrap();
}
#[derive(Debug)]
struct SandBox(*mut i32);
unsafe impl Send for SandBox {}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/tokio_semaphore.rs | rust基础/线程同步和线程安全/src/bin/tokio_semaphore.rs | use std::{sync::Arc, thread, time::Duration};
use tokio::sync::Semaphore;
#[tokio::main]
async fn main() {
// 初始化信号量为3
let semaphore: Arc<Semaphore> = Arc::new(Semaphore::new(3));
let mut join_handles = Vec::new();
// 获取一个信号量许可，信号量减1
let permit = semaphore.clone().acquire_owned().await.unwrap();
println!("start {:?}", permit);
//drop(permit);
for i in 0..5 {
let permit = semaphore.clone().acquire_owned().await.unwrap();
join_handles.push(tokio::spawn(async move {
println!("i:{i}");
thread::sleep(Duration::from_secs(10));
println!("inner {:?}", permit);
drop(permit);
}));
}
for handle in join_handles {
handle.await.unwrap();
}
let permit = semaphore.clone().acquire_owned().await.unwrap();
println!("end {:?}", permit);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/rw_lock.rs | rust基础/线程同步和线程安全/src/bin/rw_lock.rs | use std::sync::RwLock;
/// 读写锁
fn main() {
// 实例化读写锁
let lock = RwLock::new(100);
// 同一时间允许多个读
{
let num1 = lock.read().unwrap();
let num2 = lock.read().unwrap();
assert_eq!(*num1, 100);
assert_eq!(*num2, 100)
} //<-------------读锁在此离开作用域，释放读锁
// 同一时间只运行一个写
{
let mut num3 = lock.write().unwrap();
*num3 += 1;
assert_eq!(*num3, 101);
} //<-------------写锁在此离开作用域，释放写锁
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/mpsc_try_recv.rs | rust基础/线程同步和线程安全/src/bin/mpsc_try_recv.rs | use std::{sync::mpsc, thread, time::Duration};
fn main() {
// 创建一个通道，返回元组(发送者，接收者)
let (sender, receiver) = mpsc::channel();
// 创建子线程向主线程发送消息
thread::spawn(move || {
// 使用move将sender的所有权移动到子线程中
// send方法返回Result，因为能发送失败
// 这里直接unwrap取出Ok
let msg = String::from("加油2024");
let result = sender.send(msg);
// 编译报错，msg没有实现COPY特征，所有权被转移
//println!("msg ：{msg}");
if let Ok(()) = result {
println!("子线程发送消息成功");
} else {
println!("子线程发送消息失败");
}
});
// 在主线程中接收消息
// try_recv不会阻塞当前线程，没有消息立即返回一个错误
thread::sleep(Duration::from_millis(1));
let msg = receiver.try_recv();
if let Ok(msg) = msg {
println!("接收到子线程发送的消息:{msg}");
} else {
println!("没有收到消息...{:?}", msg);
}
// if let Ok(msg) = msg {
// println!("接收到子线程发送的消息:{msg}");
// } else {
// println!("没有收到消息...{:?}", msg);
// }
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/rust基础/线程同步和线程安全/src/bin/impl_send_sync_for_pointer.rs | rust基础/线程同步和线程安全/src/bin/impl_send_sync_for_pointer.rs | use std::{sync::Arc, thread};
/// 为裸指针实现send和sync特征
fn main() {
let num = 123;
let sand_box = Arc::new(SandBox(num as *mut i32));
let sand_box_clone = sand_box.clone();
let handle = thread::spawn(move || {
println!("sand box value:{:?}", sand_box_clone);
});
handle.join().unwrap();
println!("sand box value:{:?}", sand_box);
}
#[derive(Debug)]
struct SandBox(*mut i32);
unsafe impl Send for SandBox {}
unsafe impl Sync for SandBox {}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/self_in_cpu/src/main.rs | 提升篇/self_in_cpu/src/main.rs | //! cpu眼里的self
pub fn get(pointer: *const A) -> *const A {
pointer
}
pub struct A;
impl A {
pub fn get(&self) -> *const A {
self as *const A
}
}
pub fn main() {
let b = A.get();
let d = get(b);
println!("b:{:p} d:{:p}", b, d);
}
// example::get::h64f063fea484ae4e:
// mov rax, rdi
// ret
// example::A::get::h6be26c2822996cdb:
// mov rax, rdi
// ret
// example::main::h238d10f39e0a48fc:
// push rax
// lea rdi, [rip + .L__unnamed_1]
// call qword ptr [rip + example::A::get::h6be26c2822996cdb@GOTPCREL]
// mov rdi, rax
// call qword ptr [rip + example::get::h64f063fea484ae4e@GOTPCREL]
// pop rax
// ret
// .L__unnamed_1:
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/routers.rs | 提升篇/actix_web_service/src/routers.rs | use crate::handlers::{course::*, general::health_check_handler};
use actix_web::web::{self};
pub fn general_routes(cfg: &mut web::ServiceConfig) {
cfg.route("/health", web::get().to(health_check_handler));
}
pub fn course_routes(cfg: &mut web::ServiceConfig) {
cfg.service(
web::scope("/courses")
.route("/", web::post().to(post_new_course))
.route("/{teacher_id}", web::get().to(get_courses_for_teacher))
.route(
"/{teacher_id}/{course_id}",
web::get().to(get_course_detail),
)
.route("/{teacher_id}/{course_id}", web::delete().to(delete_course))
.route(
"/{teacher_id}/{course_id}",
web::put().to(update_course_details),
),
);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/state.rs | 提升篇/actix_web_service/src/state.rs | use std::sync::Mutex;
use sqlx::PgPool;
pub struct AppState {
pub health_check_response: String,
pub visit_count: Mutex<i32>,
pub db: PgPool,
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/error.rs | 提升篇/actix_web_service/src/error.rs | use actix_web::{error, http::StatusCode, HttpResponse};
use serde::Serialize;
use sqlx::error::Error as SQLError;
use std::fmt;
#[derive(Debug, Serialize)]
pub enum MyError {
DBError(String),
ActixError(String),
NotFound(String),
}
#[derive(Debug, Serialize)]
pub struct MyErrorResponse {
error_message: String,
}
impl MyError {
fn error_response(&self) -> String {
match self {
MyError::DBError(msg) => {
println!("Database error occured:{:?}", msg);
"Database Error".into()
}
MyError::ActixError(msg) => {
println!("Serice Error occured:{:?}", msg);
"Internal Server error".into()
}
MyError::NotFound(msg) => {
println!("Not Found error occured:{:?}", msg);
msg.into()
}
}
}
}
impl error::ResponseError for MyError {
fn status_code(&self) -> StatusCode {
match self {
MyError::DBError(_msg) | MyError::ActixError(_msg) => StatusCode::INTERNAL_SERVER_ERROR,
MyError::NotFound(_msg) => StatusCode::NOT_FOUND,
}
}
fn error_response(&self) -> HttpResponse<actix_web::body::BoxBody> {
HttpResponse::build(self.status_code()).json(MyErrorResponse {
error_message: self.error_response(),
})
}
}
impl fmt::Display for MyError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self)
}
}
impl From<actix_web::error::Error> for MyError {
fn from(value: actix_web::error::Error) -> Self {
MyError::ActixError(value.to_string())
}
}
impl From<SQLError> for MyError {
fn from(value: SQLError) -> Self {
MyError::DBError(value.to_string())
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/db_access/course.rs | 提升篇/actix_web_service/src/db_access/course.rs | use crate::error::MyError;
use crate::models::course::{Course, CreateCourse, UpdateCourse};
use sqlx::postgres::PgPool;
pub async fn get_courses_for_teacher_db(
pool: &PgPool,
teacher_id: i32,
) -> Result<Vec<Course>, MyError> {
let rows: Vec<Course> = sqlx::query_as!(
Course,
r#"SELECT * FROM course WHERE teacher_id = $1"#,
teacher_id
)
.fetch_all(pool)
.await?;
Ok(rows)
}
pub async fn get_course_details_db(
pool: &PgPool,
teacher_id: i32,
course_id: i32,
) -> Result<Course, MyError> {
let row = sqlx::query_as!(
Course,
r#"SELECT * FROM course
WHERE teacher_id = $1 and id = $2"#,
teacher_id,
course_id
)
.fetch_optional(pool)
.await?;
if let Some(course) = row {
Ok(course)
} else {
Err(MyError::NotFound("Course didn't founded".into()))
}
}
pub async fn post_new_course_db(
pool: &PgPool,
new_course: CreateCourse,
) -> Result<Course, MyError> {
let row = sqlx::query_as!(
Course,
r#"INSERT INTO course (teacher_id, name, description, format, structure, duration, price, language, level)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
RETURNING id, teacher_id, name, time, description, format, structure, duration, price, language, level"#,
new_course.teacher_id, new_course.name, new_course.description,
new_course.format, new_course.structure, new_course.duration,
new_course.price, new_course.language, new_course.level
)
.fetch_one(pool)
.await?;
Ok(row)
}
pub async fn delete_course_db(pool: &PgPool, teacher_id: i32, id: i32) -> Result<String, MyError> {
let course_row = sqlx::query!(
"DELETE FROM course where teacher_id = $1 and id=$2",
teacher_id,
id,
)
.execute(pool)
.await?;
Ok(format!(r#"\"del_result\":{:?}"#, course_row))
}
pub async fn update_course_details_db(
pool: &PgPool,
teacher_id: i32,
id: i32,
update_course: UpdateCourse,
) -> Result<Course, MyError> {
let current_course_row = sqlx::query_as!(
Course,
"SELECT * FROM course where teacher_id=$1 and id=$2",
teacher_id,
id
)
.fetch_one(pool)
.await
.map_err(|_err| MyError::NotFound("Course Id not found".into()))?;
let name: String = if let Some(name) = update_course.name {
name
} else {
current_course_row.name
};
let description: String = if let Some(description) = update_course.description {
description
} else {
current_course_row
.description
.unwrap_or_default()
};
let format: String = if let Some(format) = update_course.format {
format
} else {
current_course_row
.format
.unwrap_or_default()
};
let structure: String = if let Some(structure) = update_course.structure {
structure
} else {
current_course_row
.structure
.unwrap_or_default()
};
let duration: String = if let Some(duration) = update_course.duration {
duration
} else {
current_course_row
.duration
.unwrap_or_default()
};
let level: String = if let Some(level) = update_course.level {
level
} else {
current_course_row
.level
.unwrap_or_default()
};
let language: String = if let Some(language) = update_course.language {
language
} else {
current_course_row
.language
.unwrap_or_default()
};
let price: i32 = if let Some(price) = update_course.price {
price
} else {
current_course_row
.price
.unwrap_or_default()
};
let course_row = sqlx::query_as!(
Course,
"UPDATE course SET name = $1, description = $2, format = $3,
structure = $4, duration = $5, price = $6, language = $7,
level = $8 where teacher_id = $9 and id = $10
RETURNING id, teacher_id, name, time,
description, format, structure,duration, price, language, level",
name,
description,
format,
structure,
duration,
price,
language,
level,
teacher_id,
id
)
.fetch_one(pool)
.await;
if let Ok(course) = course_row {
Ok(course)
} else {
Err(MyError::NotFound("Course id not found".into()))
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/db_access/lib.rs | 提升篇/actix_web_service/src/db_access/lib.rs | pub mod course;
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/models/course.rs | 提升篇/actix_web_service/src/models/course.rs | use actix_web::web;
use chrono::NaiveDateTime;
use serde::{Deserialize, Serialize};
use crate::error::MyError;
use std::convert::TryFrom;
#[derive(Serialize, Debug, Clone, sqlx::FromRow)]
pub struct Course {
pub id: i32,
pub teacher_id: i32,
pub name: String,
pub time: Option<NaiveDateTime>,
pub description: Option<String>,
pub format: Option<String>,
pub structure: Option<String>,
pub duration: Option<String>,
pub price: Option<i32>,
pub language: Option<String>,
pub level: Option<String>,
}
#[derive(Deserialize, Debug, Clone, sqlx::FromRow)]
pub struct CreateCourse {
pub teacher_id: i32,
pub name: String,
pub description: Option<String>,
pub format: Option<String>,
pub structure: Option<String>,
pub duration: Option<String>,
pub price: Option<i32>,
pub language: Option<String>,
pub level: Option<String>,
}
#[derive(Deserialize, Debug, Clone)]
pub struct UpdateCourse {
pub name: Option<String>,
pub description: Option<String>,
pub format: Option<String>,
pub structure: Option<String>,
pub duration: Option<String>,
pub price: Option<i32>,
pub language: Option<String>,
pub level: Option<String>,
}
impl TryFrom<web::Json<CreateCourse>> for CreateCourse {
type Error = MyError;
fn try_from(course: web::Json<CreateCourse>) -> Result<Self, Self::Error> {
Ok(CreateCourse {
teacher_id: course.teacher_id,
name: course.name.clone(),
description: course.description.clone(),
format: course.format.clone(),
structure: course.structure.clone(),
duration: course.duration.clone(),
price: course.price,
language: course.language.clone(),
level: course.level.clone(),
})
}
}
impl From<web::Json<UpdateCourse>> for UpdateCourse {
fn from(course: web::Json<UpdateCourse>) -> Self {
UpdateCourse {
name: course.name.clone(),
description: course.description.clone(),
format: course.format.clone(),
structure: course.structure.clone(),
duration: course.duration.clone(),
price: course.price,
language: course.language.clone(),
level: course.level.clone(),
}
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/models/lib.rs | 提升篇/actix_web_service/src/models/lib.rs | pub mod course;
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/bin/quick-start.rs | 提升篇/actix_web_service/src/bin/quick-start.rs | use actix_web::HttpResponse;
use actix_web::{web, App, HttpServer};
use std::io;
use serde::Deserialize;
use serde::Serialize;
#[derive(Debug,Serialize,Deserialize)]
struct Hello{
msg:String
}
#[actix_rt::main]
async fn main()-> io::Result<()>{
HttpServer::new(move ||{
App::new().service(web::resource("/").route(web::post().to(index)))
})
.bind("127.0.0.1:9999")?
.run()
.await
}
async fn index(item:web::Json<Hello>) -> HttpResponse {
HttpResponse::Ok().json(&item.msg)
} | rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/bin/teacher-service.rs | 提升篇/actix_web_service/src/bin/teacher-service.rs | use actix_web::{web, App, HttpServer};
use dotenv::dotenv;
use sqlx::postgres::PgPoolOptions;
use std::sync::Mutex;
use std::{env, io};
#[path = "../handlers/lib.rs"]
mod handlers;
#[path = "../routers.rs"]
mod routers;
#[path = "../state.rs"]
mod state;
#[path = "../models/lib.rs"]
mod models;
#[path = "../db_access/lib.rs"]
mod db_access;
#[path = "../error.rs"]
mod error;
use routers::{course_routes, general_routes};
use state::AppState;
#[actix_rt::main]
async fn main() -> io::Result<()> {
dotenv().ok();
let database_url = env::var("DATABASE_URL").expect("DATABASE_URL没有设置");
let db_pool = PgPoolOptions::new()
.connect(&database_url)
.await
.unwrap();
let shared_data = web::Data::new(AppState {
health_check_response: "ok".to_string(),
visit_count: Mutex::new(0),
db: db_pool,
});
let app = move || {
App::new()
.app_data(shared_data.clone())
.configure(general_routes)
.configure(course_routes)
};
HttpServer::new(app)
.bind("127.0.0.1:3000")?
.run()
.await
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/handlers/course.rs | 提升篇/actix_web_service/src/handlers/course.rs | use crate::db_access::course::*;
use crate::error::MyError;
use crate::models::course::{CreateCourse, UpdateCourse};
use crate::state::AppState;
use actix_web::{web, HttpResponse};
pub async fn post_new_course(
new_course: web::Json<CreateCourse>,
app_state: web::Data<AppState>,
) -> Result<HttpResponse, MyError> {
post_new_course_db(&app_state.db, new_course.try_into()?)
.await
.map(|course| HttpResponse::Ok().json(course))
}
pub async fn get_courses_for_teacher(
app_state: web::Data<AppState>,
params: web::Path<i32>,
) -> Result<HttpResponse, MyError> {
let teacher_id = params.into_inner();
get_courses_for_teacher_db(&app_state.db, teacher_id)
.await
.map(|courses| HttpResponse::Ok().json(courses))
}
pub async fn get_course_detail(
params: web::Path<(i32, i32)>,
app_state: web::Data<AppState>,
) -> Result<HttpResponse, MyError> {
let (teacher_id, course_id) = params.into_inner();
println!("teacher_id:{teacher_id} course_id:{course_id}");
get_course_details_db(&app_state.db, teacher_id, course_id)
.await
.map(|course| HttpResponse::Ok().json(course))
}
pub async fn delete_course(
app_state: web::Data<AppState>,
params: web::Path<(i32, i32)>,
) -> Result<HttpResponse, MyError> {
let (teacher_id, course_id) = params.into_inner();
delete_course_db(&app_state.db, teacher_id, course_id)
.await
.map(|resp| HttpResponse::Ok().json(resp))
}
pub async fn update_course_details(
update_course: web::Json<UpdateCourse>,
app_state: web::Data<AppState>,
params: web::Path<(i32, i32)>,
) -> Result<HttpResponse, MyError> {
let (teacher_id, course_id) = params.into_inner();
update_course_details_db(&app_state.db, teacher_id, course_id, update_course.into())
.await
.map(|course| HttpResponse::Ok().json(course))
}
#[cfg(test)]
mod tests {
use super::*;
use actix_web::http::StatusCode;
use dotenv::dotenv;
use sqlx::postgres::PgPoolOptions;
use std::env;
use std::sync::Mutex;
#[actix_rt::test]
async fn post_course_test() {
dotenv().ok();
let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
let db_pool = PgPoolOptions::new()
.connect(&db_url)
.await
.unwrap();
let app_state: web::Data<AppState> = web::Data::new(AppState {
health_check_response: "".to_string(),
visit_count: Mutex::new(0),
db: db_pool,
});
let course = web::Json(CreateCourse {
teacher_id: 1,
name: "Test course".into(),
description: Some("This is a course".into()),
format: None,
structure: None,
duration: None,
price: None,
language: Some("English".into()),
level: Some("Beginner".into()),
});
let resp = post_new_course(course, app_state)
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
}
#[actix_rt::test]
async fn get_all_courses_success() {
dotenv().ok();
let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
let db_pool = PgPoolOptions::new()
.connect(&db_url)
.await
.unwrap();
let app_state: web::Data<AppState> = web::Data::new(AppState {
health_check_response: "".to_string(),
visit_count: Mutex::new(0),
db: db_pool,
});
let teacher_id: web::Path<i32> = web::Path::from(1);
let resp = get_courses_for_teacher(app_state, teacher_id)
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
}
#[actix_rt::test]
async fn get_one_course_success() {
dotenv().ok();
let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
let db_pool = PgPoolOptions::new()
.connect(&db_url)
.await
.unwrap();
let app_state: web::Data<AppState> = web::Data::new(AppState {
health_check_response: "".to_string(),
visit_count: Mutex::new(0),
db: db_pool,
});
let params: web::Path<(i32, i32)> = web::Path::from((1, 1));
let resp = get_course_detail(app_state, params)
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
}
#[actix_rt::test]
async fn get_one_course_failure() {
dotenv().ok();
let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
let db_pool = PgPoolOptions::new()
.connect(&db_url)
.await
.unwrap();
let app_state: web::Data<AppState> = web::Data::new(AppState {
health_check_response: "".to_string(),
visit_count: Mutex::new(0),
db: db_pool,
});
let params: web::Path<(i32, i32)> = web::Path::from((1, 100));
let resp = get_course_detail(app_state, params).await;
use actix_web::ResponseError;
match resp {
Ok(_) => println!("Something went wrong"),
Err(err) => assert_eq!(err.status_code(), StatusCode::NOT_FOUND),
}
}
#[actix_rt::test]
async fn delete_course_success() {
dotenv().ok();
let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
let db_pool = PgPoolOptions::new()
.connect(&db_url)
.await
.unwrap();
let app_state: web::Data<AppState> = web::Data::new(AppState {
health_check_response: "".to_string(),
visit_count: Mutex::new(0),
db: db_pool,
});
let params: web::Path<(i32, i32)> = web::Path::from((1, 3));
let resp = delete_course(app_state, params)
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::OK);
}
#[actix_rt::test]
async fn delete_course_failure() {
dotenv().ok();
let db_url = env::var("DATABASE_URL").expect("DATABASE_URL 没有在 .env 文件里设置");
let db_pool = PgPoolOptions::new()
.connect(&db_url)
.await
.unwrap();
let app_state: web::Data<AppState> = web::Data::new(AppState {
health_check_response: "".to_string(),
visit_count: Mutex::new(0),
db: db_pool,
});
let params: web::Path<(i32, i32)> = web::Path::from((1, 301));
let resp = delete_course(app_state, params).await;
use actix_web::ResponseError;
match resp {
Ok(_) => println!("Something went wrong"),
Err(err) => assert_eq!(err.status_code(), StatusCode::NOT_FOUND),
}
}
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/handlers/general.rs | 提升篇/actix_web_service/src/handlers/general.rs | use crate::state::AppState;
use actix_web::{web, HttpResponse};
pub async fn health_check_handler(app_state: web::Data<AppState>) -> HttpResponse {
println!("incoming for health check");
let health_check_response = &app_state.health_check_response;
let mut visit_count = app_state.visit_count.lock().unwrap();
let response = format!("{} {} times", health_check_response, visit_count);
*visit_count += 1;
HttpResponse::Ok().json(&response)
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/提升篇/actix_web_service/src/handlers/lib.rs | 提升篇/actix_web_service/src/handlers/lib.rs | pub mod course;
pub mod general;
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/数据结构和算法/linear_data_structure/src/bin/use_stack_decimal_conversion.rs | 数据结构和算法/linear_data_structure/src/bin/use_stack_decimal_conversion.rs | //!使用栈进行16进制以内的任意进制转换
use stack::Stack;
mod stack;
fn decimal_conversion(mut origin_num: u32, base: u32) -> String {
let digits = [
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'A', 'B', 'C', 'D', 'E', 'F',
];
// 使用转辗相除法
let mut stack = Stack::new();
// 余数入栈
while origin_num > 0 {
let rem = origin_num % base;
stack.push(rem);
origin_num /= base;
}
// 出栈并拼装成字符串
let mut result = "".to_string();
while !stack.is_empty() {
let rem = stack.pop().unwrap() as usize;
result += &digits[rem].to_string();
}
result
}
fn main() {
let num = 1024;
println!("{num} 转换为2进制:{}", decimal_conversion(num, 2));
println!("{num} 转换为3进制:{}", decimal_conversion(num, 3));
println!("{num} 转换为4进制:{}", decimal_conversion(num, 4));
println!("{num} 转换为5进制:{}", decimal_conversion(num, 5));
println!("{num} 转换为6进制:{}", decimal_conversion(num, 6));
println!("{num} 转换为7进制:{}", decimal_conversion(num, 7));
println!("{num} 转换为8进制:{}", decimal_conversion(num, 8));
println!("{num} 转换为9进制:{}", decimal_conversion(num, 9));
println!("{num} 转换为10进制:{}", decimal_conversion(num, 10));
println!("{num} 转换为11进制:{}", decimal_conversion(num, 11));
println!("{num} 转换为12进制:{}", decimal_conversion(num, 12));
println!("{num} 转换为13进制:{}", decimal_conversion(num, 13));
println!("{num} 转换为14进制:{}", decimal_conversion(num, 14));
println!("{num} 转换为15进制:{}", decimal_conversion(num, 15));
println!("{num} 转换为16进制:{}", decimal_conversion(num, 16));
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/数据结构和算法/linear_data_structure/src/bin/use_stack_par_checker.rs | 数据结构和算法/linear_data_structure/src/bin/use_stack_par_checker.rs | //! 使用栈进行"括号"匹配
//! 这里的"括号"包括[]、{}、()
use std::vec;
use crate::stack::Stack;
mod stack;
/// 判断是否匹配
fn matcher(left: char, right: char) -> bool {
let lefts = "([{";
let rights = ")]}";
lefts.find(left) == rights.find(right)
}
// 使用栈判断括号是否匹配
fn par_checher(input: &str) -> bool {
if input.is_empty() {
return false;
} else {
let mut chars = vec![];
for c in input.chars() {
chars.push(c);
}
// 记录chars的下标
let mut index = 0;
// 标记是否匹配
let mut balance = true;
let mut stack = Stack::new();
// 借助栈匹配字符，直至匹配完毕或者出现不匹配
while index < chars.len() && balance {
let i = chars[index];
// 如果i='['或i='{'或i='('，则入栈
if i == '(' || i == '[' || i == '{' {
stack.push(i);
}
// 如果i=']' 或i='}'或i=')',判断是否平衡
if i == ')' || i == '}' || i == ']' {
if stack.is_empty() {
balance = false;
} else {
let top = stack.pop().unwrap();
if !matcher(top, i) {
balance = false;
}
}
}
index += 1;
}
balance && stack.is_empty()
}
}
fn main() {
let a = "(3+2)-5*{5*7}+[{()}]";
println!("{a} is balance:{}", par_checher(a));
let a = "(3+2)-5*{5*7}+[{(}}]";
println!("{a} is balance:{}", par_checher(a));
let a = "(([{([1+1-2+232*({[]})])}]))";
println!("{a} is balance:{}", par_checher(a));
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/数据结构和算法/linear_data_structure/src/bin/use_queue_josephus_circle.rs | 数据结构和算法/linear_data_structure/src/bin/use_queue_josephus_circle.rs | //! 约瑟夫环(最后剩下谁，烫手的山芋游戏）
mod queue;
use queue::Queue;
fn josephus_circle(names: Vec<&str>, num: usize) -> &str {
// 将参与游戏的名字入队列
let mut q = Queue::new(names.len());
for name in names {
let _i = q.enqueue(name);
}
while q.len() > 1 {
// 数num-1次，相当于做num-1次出队入队操作,第num次的人将被移除
for _i in 0..num {
let name = q.dequeue().unwrap();
let _i = q.enqueue(name);
}
let killed_name = q.dequeue().unwrap();
println!("{killed_name} is out!!");
}
// 返回剩下的最后一个人
q.dequeue().unwrap()
}
fn main() {
let names = vec![
"小花", "小黑", "小白", "小黄", "小含", "小满", "小就", "小来",
];
let survivor = josephus_circle(names, 7);
println!("最后的幸存者:{survivor}");
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/数据结构和算法/linear_data_structure/src/bin/stack.rs | 数据结构和算法/linear_data_structure/src/bin/stack.rs | //! 实现栈数据结构
#[derive(Debug)]
pub struct Stack<T> {
size: usize, // 栈大小
data: Vec<T>, // 栈数据，泛型T
}
impl<T> Stack<T> {
// 初始化空栈
pub fn new() -> Self {
Self {
size: 0,
data: vec![],
}
}
// 判空
pub fn is_empty(&self) -> bool {
self.size == 0
}
// 栈元素个数
pub fn len(&self) -> usize {
self.size
}
// 清空栈
pub fn clear(&mut self) {
self.size = 0;
self.data.clear();
}
// 将数据压入栈顶
pub fn push(&mut self, val: T) {
self.data.push(val);
self.size += 1;
}
// 将数据从栈顶弹出
pub fn pop(&mut self) -> Option<T> {
if self.is_empty() {
return None;
} else {
self.size -= 1;
self.data.pop()
}
}
// “偷窥”栈顶元素，返回栈顶元素的引用
pub fn peek(&self) -> Option<&T> {
if self.is_empty() {
return None;
} else {
self.data.get(self.len() - 1)
}
}
// 返回栈顶元素的可变引用
pub fn peek_mut(&mut self) -> Option<&mut T> {
if self.is_empty() {
return None;
} else {
self.data.get_mut(self.size - 1)
}
}
// 为栈实现迭代器
// 将栈转换为迭代器
pub fn into_iter(self) -> IntoIter<T> {
IntoIter(self)
}
// 获取不可变引用迭代器
pub fn iter(&self) -> Iter<T> {
let mut iter = Iter(Stack::new());
for i in self.data.iter() {
iter.0.push(i);
}
iter
}
// 获取可变引用迭代器
pub fn iter_mut(&mut self) -> IterMut<T> {
let mut iter_mut = IterMut(vec![]);
for i in self.data.iter_mut() {
iter_mut.0.push(i);
}
iter_mut
}
}
struct IntoIter<T>(Stack<T>);
impl<T: Clone> Iterator for IntoIter<T> {
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
if self.0.is_empty() {
None
} else {
self.0.size -= 1;
self.0.pop()
}
}
}
struct Iter<'a, T: 'a>(Stack<&'a T>);
impl<'a, T> Iterator for Iter<'a, T> {
type Item = &'a T;
fn next(&mut self) -> Option<Self::Item> {
self.0.pop()
}
}
struct IterMut<'a, T: 'a>(Vec<&'a mut T>);
impl<'a, T> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
fn next(&mut self) -> Option<Self::Item> {
self.0.pop()
}
}
fn main() {
let mut s = Stack::new();
s.push(100);
s.push(200);
s.push(99);
s.push(888);
// 不可变引用迭代器
let sum = s.iter().sum::<i32>();
println!("sum:{sum}"); // 输出1287
// 可变引用迭代器
// 输出ele:8880 ele:990 ele:2000 ele:1000
s.iter_mut()
.map(|item| *item * 10)
.for_each(|ele| print!("ele:{ele} "));
// 通过可变引用修改值
for i in s.iter_mut() {
*i += 10;
}
println!("stack:{:?}", s); // 输出stack:Stack { size: 4, data: [110, 210, 109, 898] }
// 将消费stack生成迭代器
let sum = s.into_iter().sum::<i32>();
println!("sum:{sum}"); // 输出1327
// stack已被消费，所有权已经转移，下面代码会报编译错误
// println!("stack:{:?}",s);
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/数据结构和算法/linear_data_structure/src/bin/dequeue.rs | 数据结构和算法/linear_data_structure/src/bin/dequeue.rs | //! 双端队列
#[derive(Debug)]
pub struct Dequeue<T> {
cap: usize,
datas: Vec<T>,
}
impl<T> Dequeue<T> {
pub fn new(cap: usize) -> Self {
Self {
cap: cap,
datas: Vec::with_capacity(cap),
}
}
pub fn is_empty(&self) -> bool {
self.datas.len() == 0
}
pub fn is_full(&self) -> bool {
self.len() == self.cap
}
pub fn len(&self) -> usize {
self.datas.len()
}
pub fn clear(&mut self) {
self.datas = Vec::with_capacity(self.cap)
}
// 在队首添加元素(vec的末尾为队首)
pub fn add_front(&mut self, val: T) -> Result<(), String> {
if self.is_full() {
return Err("没有空间".to_string());
}
self.datas.push(val);
Ok(())
}
// 从队首移除元素
pub fn remove_front(&mut self) -> Option<T> {
if self.is_empty() {
None
} else {
self.datas.pop()
}
}
// 在队尾插入元素(vec的开始为队尾)
pub fn add_rear(&mut self, val: T) -> Result<(), String> {
if self.is_full() {
return Err("没有空间".to_string());
}
self.datas.insert(0, val);
Ok(())
}
// 从队尾移除元素
pub fn remove_rear(&mut self) -> Option<T> {
if self.is_empty() {
None
} else {
Some(self.datas.remove(0))
}
}
// 实现迭代功能
pub fn into_iter(self) -> IntoIter<T> {
IntoIter(self)
}
fn iter(&self) -> Iter<T> {
let mut iter = Iter(vec![]);
for i in self.datas.iter() {
iter.0.push(i);
}
iter
}
pub fn iter_mut(&mut self) -> IterMut<T> {
let mut iter_mut = IterMut(vec![]);
for i in self.datas.iter_mut() {
iter_mut.0.push(i);
}
iter_mut
}
}
struct IterMut<'a, T>(Vec<&'a mut T>);
impl<'a, T> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
fn next(&mut self) -> Option<Self::Item> {
if self.0.len() == 0 {
None
} else {
Some(self.0.remove(0))
}
}
}
struct Iter<'a, T>(Vec<&'a T>);
impl<'a, T> Iterator for Iter<'a, T> {
type Item = &'a T;
fn next(&mut self) -> Option<Self::Item> {
if self.0.len() == 0 {
None
} else {
Some(self.0.remove(0))
}
}
}
struct IntoIter<T>(Dequeue<T>);
impl<T> Iterator for IntoIter<T> {
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
if self.0.is_empty() {
None
} else {
self.0.remove_front()
}
}
}
fn main() {
fn test1() {
let mut d = Dequeue::new(2);
let _r3 = d.add_rear(3);
let _r4 = d.add_rear(4);
if let Err(error) = d.add_front(5) {
println!("add_front error: {error}");
}
println!("{:?}", d);
match d.remove_rear() {
Some(data) => println!("remove rear data {data}"),
None => println!("empty deque"),
}
match d.remove_front() {
Some(data) => println!("remove front data {data}"),
None => println!("empty deque"),
}
println!("empty: {}, len: {}", d.is_empty(), d.len());
println!("full: {}, {:?}", d.is_full(), d);
d.clear();
println!("{:?}", d);
}
fn test2() {
let mut d = Dequeue::new(2);
let _r1 = d.add_front(1);
let _r4 = d.add_rear(4);
let sum1 = d.iter().sum::<i32>();
let mut sum = 0;
for item in d.iter_mut() {
*item += 1;
sum += 1;
}
let sum2 = d.iter().sum::<i32>();
println!("{sum1} + {sum} = {sum2}");
assert_eq!(7, d.into_iter().sum::<i32>());
}
test1();
test2();
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/数据结构和算法/linear_data_structure/src/bin/lstack.rs | 数据结构和算法/linear_data_structure/src/bin/lstack.rs | //!基于链表实现的栈数据结构
mod linklist;
use std::fmt::{Debug, Display};
// 节点引用类型
type NodeRef<T> = Option<Box<Node<T>>>;
// 链表节点
#[derive(Debug)]
struct Node<T> {
// 数据
elem: T,
// 下一个节点
next: NodeRef<T>,
}
impl<T: Debug + Display> Node<T> {
fn new(data: T) -> Self {
Self {
elem: data,
next: None,
}
}
}
struct LStack<T> {
size: usize,
top: NodeRef<T>,
}
impl<T: Debug + Display> LStack<T> {
fn new() -> Self {
Self { size: 0, top: None }
}
fn is_empty(&self) -> bool {
0 == self.size
}
fn len(&self) -> usize {
self.size
}
fn clear(&mut self) {
self.size = 0;
self.top = None;
}
fn push(&mut self, val: T) {
let mut node = Node::new(val);
node.next = self.top.take();
self.top = Some(Box::new(node));
self.size += 1;
}
fn pop(&mut self) -> Option<T> {
self.top.take().map(|node| {
let node = *node;
self.top = node.next;
self.size -= 1;
node.elem
})
}
fn peek(&self) -> Option<&T> {
self.top.as_ref().map(|node| &node.elem)
}
fn peek_mut(&mut self) -> Option<&mut T> {
self.top.as_deref_mut().map(|node| &mut node.elem)
}
// 迭代器
fn into_iter(self) -> IntoIter<T> {
IntoIter(self)
}
fn iter(&self) -> Iter<T> {
Iter(self.top.as_deref())
}
fn iter_mut(&mut self) -> IterMut<T> {
IterMut(self.top.as_deref_mut())
}
fn display(&self) {
for i in self.iter() {
println!("ele:{i}");
}
}
}
struct IterMut<'a, T>(Option<&'a mut Node<T>>);
impl<'a, T: 'a + Debug + Display> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
fn next(&mut self) -> Option<Self::Item> {
self.0.take().map(|node| {
self.0 = node.next.as_deref_mut();
&mut node.elem
})
}
}
struct Iter<'a, T: 'a>(Option<&'a Node<T>>);
impl<'a, T: 'a + Debug + Display> Iterator for Iter<'a, T> {
type Item = &'a T;
fn next(&mut self) -> Option<Self::Item> {
self.0.map(|node| {
self.0 = node.next.as_deref();
&node.elem
})
}
}
struct IntoIter<T>(LStack<T>);
impl<T: Debug + Display> Iterator for IntoIter<T> {
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
self.0.pop()
}
}
fn main() {
let mut s = LStack::new();
s.push(11);
s.push(22);
s.display();
for item in s.iter_mut() {
*item += 2024;
}
println!("-----------");
s.display();
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/数据结构和算法/linear_data_structure/src/bin/linklist.rs | 数据结构和算法/linear_data_structure/src/bin/linklist.rs | //! 链表
use std::fmt::Debug;
// 节点引用类型
type NodeRef<T> = Option<Box<Node<T>>>;
#[derive(Debug)]
struct List<T: Debug> {
// 链表大小
size: usize,
// 头结点
head: NodeRef<T>,
}
// 链表节点
#[derive(Debug)]
struct Node<T> {
// 数据
elem: T,
// 下一个节点
next: NodeRef<T>,
}
impl<T: Debug> List<T> {
fn new() -> Self {
Self {
size: 0,
head: None,
}
}
// 判断链表是否为空
fn is_empty(&self) -> bool {
self.size == 0
}
// 链表长度
fn len(&self) -> usize {
self.size
}
// 清空链表
fn clear(&mut self) {
self.size = 0;
self.head = None;
}
// 添加新节点
fn push(&mut self, ele: T) {
let node = Box::new(Node {
elem: ele,
next: self.head.take(),
});
self.head = Some(node);
self.size += 1;
}
// 取出头节点数据
fn pop(&mut self) -> Option<T> {
self.head.take().map(|node| {
self.head = node.next;
self.size -= 1;
node.elem
})
}
// 查看引用值
fn peek(&self) -> Option<&T> {
self.head.as_ref().map(|node| &node.elem)
}
fn peek_mut(&mut self) -> Option<&mut T> {
self.head.as_mut().map(|node| &mut node.elem)
}
// 转换为迭代器
fn into_iter(self) -> IntoIter<T> {
IntoIter(self)
}
fn iter(&self) -> Iter<T> {
Iter(self.head.as_deref())
}
fn iter_mut(&mut self) -> IterMut<T> {
IterMut(self.head.as_deref_mut())
}
fn display(&self) {
for i in self.iter() {
println!("value:{:#?}", i);
}
}
}
// 释放链表
impl<T: Debug> Drop for List<T> {
fn drop(&mut self) {
let mut node_ref = self.head.take();
while let Some(mut node) = node_ref {
// 获取所有权并释放数据
node_ref = node.next.take();
}
}
}
struct IterMut<'a, T: 'a>(Option<&'a mut Node<T>>);
impl<'a, T> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
fn next(&mut self) -> Option<Self::Item> {
self.0.take().map(|node| {
self.0 = node.next.as_deref_mut();
&mut node.elem
})
}
}
struct Iter<'a, T: 'a>(Option<&'a Node<T>>);
impl<'a, T> Iterator for Iter<'a, T> {
type Item = &'a T;
fn next(&mut self) -> Option<Self::Item> {
self.0.map(|node| {
self.0 = node.next.as_deref();
&node.elem
})
}
}
#[derive(Debug)]
struct IntoIter<T: Debug>(List<T>);
impl<T: Debug> Iterator for IntoIter<T> {
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
self.0.pop()
}
}
fn main() {
let mut list = List::new();
list.push(10);
list.push(20);
list.push(30);
println!("原始值....");
list.display();
let iter_mut = list.iter_mut();
for i in iter_mut {
// 元素乘以100
*i *= 100
}
println!("改变之后...");
list.display();
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
reganzm/hug_rust | https://github.com/reganzm/hug_rust/blob/6a2801769c8b062477c2e6273af0218e0e21e75d/数据结构和算法/linear_data_structure/src/bin/use_list_create_vec.rs | 数据结构和算法/linear_data_structure/src/bin/use_list_create_vec.rs | //!使用链表创建vec
use std::fmt::Debug;
type NodeRef<T> = Option<Box<Node<T>>>;
#[derive(Debug)]
struct Node<T> {
ele: T,
next: NodeRef<T>,
}
impl<T> Node<T> {
fn new(ele: T) -> Self {
Self {
ele: ele,
next: None,
}
}
}
// 基于链表实现的Vec
#[derive(Debug)]
struct LVec<T> {
size: usize,
head: NodeRef<T>,
}
impl<T: Debug + Copy> LVec<T> {
fn new() -> Self {
Self {
size: 0,
head: None,
}
}
fn is_empty(&self) -> bool {
0 == self.size
}
fn len(&self) -> usize {
self.size
}
fn clear(&mut self) {
self.size = 0;
self.head = None
}
fn push(&mut self, elem: T) {
let node = Node::new(elem);
// 判断是否为空，如果为空则作为头结点
if self.is_empty() {
self.head = Some(Box::new(node));
} else {
// 找到链表最后一个节点并插入
let mut current = self.head.as_deref_mut().unwrap();
for _i in 0..self.size - 1 {
current = current.next.as_deref_mut().unwrap();
}
// 插入数据
current.next = Some(Box::new(node));
}
self.size += 1;
}
// 在当前LVec后面添加其它的LVec
fn extend(&mut self, other: &mut Self) {
while let Some(node) = other.head.as_deref_mut().take() {
self.push(node.ele);
other.head = node.next.take();
}
other.clear();
}
// 指定位置插入数据
fn insert(&mut self, mut index: usize, elem: T) {
// 如果指定的index大于LVec的大小，则重置为self.size
if index > self.size {
index = self.size
}
let mut node = Node::new(elem);
// 为空，作为头节点
if self.is_empty() {
self.head = Some(Box::new(node));
}
// 在头部位置插入数据
else if index == 0 {
node.next = self.head.take();
self.head = Some(Box::new(node));
}
// 在中间和尾部插入数据
else {
let mut current = self.head.as_deref_mut().unwrap();
for _i in 0..index - 1 {
// 找到插入位置
current = current.next.as_deref_mut().unwrap();
}
node.next = current.next.take();
current.next = Some(Box::new(node));
}
}
// 从尾部弹出数据
fn pop(&mut self) -> Option<T> {
if self.is_empty() {
None
} else {
self.remove(self.size - 1)
}
}
fn remove(&mut self, index: usize) -> Option<T> {
if index >= self.size {
return None;
} else {
let mut node;
if index == 0 {
node = self.head.take().unwrap();
self.head = node.next.take();
} else {
let mut current = self.head.as_deref_mut().unwrap();
for _i in 0..index - 1 {
current = current.next.as_deref_mut().unwrap();
}
node = current.next.take().unwrap();
current.next = node.next.take();
}
self.size -= 1;
Some(node.ele)
}
}
// 实现迭代器功能
fn into_iter(self) -> IntoIter<T> {
IntoIter(self)
}
fn iter(&self) -> Iter<T> {
Iter(self.head.as_deref())
}
fn iter_mut(&mut self) -> IterMut<T> {
IterMut(self.head.as_deref_mut())
}
// 打印输出
fn display(&self){
println!("--------------------");
if self.is_empty(){
println!("Empty");
}else{
for i in self.iter(){
println!("ele:{:?}",i);
}
}
println!("--------------------");
}
}
struct IterMut<'a, T: 'a>(Option<&'a mut Node<T>>);
impl<'a, T: 'a> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
fn next(&mut self) -> Option<Self::Item> {
self.0.take().map(|node| {
self.0 = node.next.as_deref_mut();
&mut node.ele
})
}
}
struct Iter<'a, T: 'a>(Option<&'a Node<T>>);
impl<'a, T: Debug + Copy> Iterator for Iter<'a, T> {
type Item = &'a T;
fn next(&mut self) -> Option<Self::Item> {
self.0.map(|node| {
self.0 = node.next.as_deref();
&node.ele
})
}
}
struct IntoIter<T>(LVec<T>);
impl<T: Debug + Copy> Iterator for IntoIter<T> {
type Item = T;
fn next(&mut self) -> Option<Self::Item> {
self.0.pop()
}
}
fn main() {
let mut l1 = LVec::new();
l1.push(30);
l1.push(40);
l1.push(50);
l1.display();
let mut l2 = LVec::new();
l2.push(999);
l2.push(888);
l1.extend(&mut l2);
l1.display();
for item in l1.iter_mut(){
*item *= 100;
}
l1.display();
}
| rust | Apache-2.0 | 6a2801769c8b062477c2e6273af0218e0e21e75d | 2026-01-04T20:24:35.074754Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.