Rust

												template

fn returns_summarizable() -> impl Summary {		T returns_summarizable() {Tweet {											return Tweet {username: String::from("ebooks"),				.username = "ebooks",content: String::from("content"),				.content = "content",reply: false,									.reply = false,retweet: false,									.retweet = false,}												};
}												}

运行时多态

pub trait Draw {									struct Draw {fn draw(&self);										virtual draw() const = 0;
}													};pub struct Screen {									struct Screen {pub components: Vec>					vector> components;
}													
impl Screen {										pub fn run(&self) {									void run() const {for component in self.components.iter() {			for (const auto& component : components) {component.draw();									component->draw();}													}}													}
}													};

pub struct Button {						struct Button : public Draw {pub width: u32,							uint32_t width;pub height: u32,						uint32_t height;pub label: String						string label;
}											
impl Draw for Button {						fn draw(&self) {						void darw() const override {}										}
}										};

函数

fn f() -> ! {}						[[noreturn]] void f() {}

注: C++的[[noreturn]]非强制约束

Lambda/闭包/匿名函数

let f = |a: i32, b: i32| -> i32 { a };	const auto f = [](int a, int b) -> int { return a; };
let f = |a, b| { a };					const auto f = [](auto a, auto b) { return a; };
let f = |a| a;							const auto f = [](auto a) { return a; };

注: rust的写法得到的是函数, 参数类型确定, 而C++的写法得到的是函数模板, 但亦可手动确定参数类型.

let s = String::from("Hello");			auto s = string("Hello");
let f = |a| s.len() + a;				const auto f = [&](auto a) { return s.length() + a; };
let f = move |a| s.len() + a;			const auto f = [s = move(s)](auto a) { return s.length() + a; };
let mut f = move |a| s.push_str(a);		auto f = [s = move(s)](string_view a) mutable { s.append(a); };

模式匹配

字面量

let x = 1;								auto x = 1;
match x {								switch (x) {1 => {},							case 1: { break; }2 => {},							case 1: { break; }_ => {},							default: { break; }
}										}

枚举

let x = Some(5);						auto x = optional(5);
let y = 10;								auto y = 10;
match x {								Some(50) => {},						if (x && *x == 50) {}Some(y) => {},						else if (x && *x == y) {}_ => {},							else {}
}										

多模式

let x = 1;								auto x = 1;
match x {								switch (x) {1 | 2 => {},						case 1: case 2: { break; }3 => {},							case 3: { break; }_ => {}								default: { break; }
}										}

区间匹配

let x = 'c';							auto x = 'c';
match x {								'a'..'j' => {},						if ('a' <= x && x <= 'j') {}'k'..'z' => {},						else if ('k' <= x && x <= 'z') {}_ => {}								else {}
}

解构

let (x, y) = (1, 2);					auto [x, y] = make_tuple(1, 2);
struct Point {							struct Point {x: i32,									int x;y: i32,									int y;
}										};
let Point { x, y } = Point { 2, 3 };	auto [x, y] = Point { 2, 3 };
match p {								Point { x, y: 0 } => {},			if (p.y == 0) {}Point { x: 0, y } => {},			else if (p.x == 0) {}Point { x, y } => {},				else {}
}

enum Message {							Quit,								struct Quit {};Move { x: i32, y: i32 },			struct Move { int x; int y; };Write(String),						struct Write { string val };ChangeColor(i32, i32, i32)			struct ChangeColor { tuple val; };
}										struct Message : variant {using variant::variant;};
let m = Message::ChangeColor(0, 1, 2);	Message m = ChangeColor { { 0, 1, 2 } };
match m {								visit([](auto& val) {Message::Quit => {						if constexpr (is_assignable_v) {},										}Message::Move { x, y } => {				else if constexpr (is_assignable_v) {auto [x, y] = val;},										}Message::Write(text) => {				else if constexpr (is_assignable_v) {auto text = move(val.val);},										}Message::ChangeColor(r, g, b) => {		else {static_assert(is_assignable_v);auto [r, g, b] = val.val;},										}
}										}, m);

迭代器

let mut v1 = vec![1, 2, 3];			auto v1 = vector{1, 2, 3};
for val in v1 {}					for (auto val : v1) {}
for val in &v1 {}					for (const auto& val : v1) {}
for val in &mut v1 {}				for (auto& val : v1) {}
for val in v1.iter() {}				for (auto& val : span(v1.cbegin(), v1.cend())) {}
for val in v1.iter_mut() {}			for (auto& val : span(v1.begin(), v1.end())) {}	

let v1 = vec![1, 2, 3];				const auto v1 = vector{1, 2, 3};
let mut it = v1.iter();				auto it = v1.begin(), itEnd = v1.end();
assert_eq!(it.next(), Some(&1));	assert(it != itEnd); assert(*it == 1);
assert_eq!(it.next(), Some(&2));	assert(++it != itEnd); assert(*it == 2);
assert_eq!(it.next(), Some(&3));	assert(++it != itEnd); assert(*it == 3);
assert_eq!(it.next(), None);		assert(++it == itEnd);

struct Counter {								struct Iter {count: i32,										using difference_type = ptrdiff_t;
}													using value_type = int;value_type count;
impl Counter {										bool operator==(Iter const& other) const {fn new() -> Counter {								 return count == other.count;Counter { count: 0 }						}}												Iter& operator++() {
}														++count;return *this;
impl Iterator for Counter {							}type Item = i32;								void operator++(int) {++*this;fn next(&mut self) -> Option {		}if self.count < 5 {							value_type operator*() const {self.count += 1;							return count;Some(self.count)						}} else {								};None								struct Counter {}											static Iter begin() { return Iter { 0 }; }}												static Iter end() { return Iter { 5 }; }
}												};fn main() {										int main() {let cnt = Counter::new();						auto cnt = Counter();for val in cnt {								for (auto val : cnt) {println!("{}", val);							cout << val << endl;}												}
}												}

let mut v1 = vec![1, 2, 3];			auto v1 = vector{1, 2, 3};
let total = v1.iter().sum();		const auto total = accumulate(v1.begin(), v1.end(), 0);
let m = v1.iter().map(|x|			auto m = v1 | views::transform([](auto x) {x + 1								return x + 1;
);									});
let v2: Vec<_> = v1.iter().map(|x|	auto v2_views = v1 | views::transform([](auto x) {x + 1								return x + 1;
).collect();						});auto v2 = vector(v2_views.begin(), v2_views.end());

let sum: i32 = Counter::new()		auto ints = views::zip(Counter(), Counter() | views::drop(1)).zip(Counter::new().skip(1))		| views::transform([](auto ab) {.map(|(a, b)| a * b)					return get<0>(ab) * get<1>(ab);}) | views::filter([](auto x) {.filter(|x| x % 3 == 0)					return x % 3 == 0;});.sum();							auto sum = accumulate(ints.being(), ints.end(), 0);

智能指针

• unique

let b = Box::new(5);				auto b = make_unique(5);

• 不变shared

let b = Rc::new(5);					auto b = make_shared(5);
let c = Rc::clone(&b);				auto c = b;
let d = b.clone();					auto d = b;
let cnt = Rc::strong_count(&d);		auto cnt = d.use_count();

• 可变shared

let b: RefCell> = RefCell::new(vec![]);		auto b = make_shared>();
b.borrow_mut().push("Hello");							b->emplace_back("Hello");
b.borrow().len();										b->size();

析构函数

struct Data {						struct Data {data: String,						string data;
}									
impl Drop for Data {			fn drop(&mut self) {				~Data() {}									}
}									};

注: 可用mem::drop将对象提前销毁, C++中只能使用}隐式销毁.

线程

let t = thread::spawn(|| {					auto t = thread([] {thread::sleep(								this_thread::sleep_for(Duration::from_millis(1000)					chrono::millisceonds(1000););											);
});											});
t.join().unwrap();							t.join();

let v = vec![1, 2, 3];						auto v = vector{1, 2, 3};
let t = thread::spawn(move || {				auto t = thread([v = move(v)] {for i in &v {}								for (const auto& i : v) {}
});											});

线程通信

管道

send recv用法

let (tx, rx) = mpsc::channel();
let t = thread::spawn(move || {tx.send(String::from("hi")).unwrap();
});
let s = rx.recv().unwrap();

迭代用法

let (tx, rx) = mpsc::channel();
let t = thread::spawn(move || {let vals = vec![String::from("a"), String::from("b"), String::from("c"),];for val in vals {tx.send(val).unwrap();};
});
for s in rx {}

多sender

let (tx1, rx) = mpsc::channel();
let tx2 = tx1.clone();
thread::spawn(move || {tx1.send(String::from("a"));
});
thread::spawn(move || {tx2.send(String::from("b"));
});

信号量

										auto num = 5;
let m = Mutex::new(5);					auto m = mutex();
{										{let mut num = m.lock().unwrap();		auto guard = lock_guard(m);*num = 6;								num = 6;
}										}

注: Mutex = tuple

let cnt = Arc::new(Mutex::new(0));
for _ in 0..10 {let cnt = Arc::clone(&cnt);thread::spawn(move || {let mut num = cnt.lock().unwrap();*num += 1;});
}

注: Arc类同Rc, 其中计数器用atomic

C交互

导入C (unsafe)

extern "C" {						extern "C" {fn abs(input: i32) -> i32;			int abs(int input);
}									}fn main() {							int main() {unsafe {							abs(233);						abs(233);}
}									}

导出C

#[no_mangle]
pub extern "C" fn f() {				extern "C" void f() {
}									}

联合体 (unsafe)

#[repr(C)]							
union MyUnion {						union MyUnion {f1: u32,							uint32_t f1;f2: f32,							float f2;
}									};let u = MyUnion { f1: 1 };			auto u = MyUnion { .f1 = 1 };
let f = unsafe { u.f1 };			auto f = u.f1;
unsafe {match u {						MyUnion { f1: 10 } => {}	if (u.f1 == 10) {}MyUnion { f2 } => {}		else {}}
}