随记

1.Rust中尽量安全的使用裸指针：

use std::ptr;
pub const unsafe fn ptr::write_unaligned<T>(dst: *mut T, src: T)

2.Rust中想定义变参函数，需要nightly版本，并将变参逻辑用C++实现。

extern "C" void MyPrintf(char* fmt, ...)
{
    va_list ArgList = 0;
    va_start(ArgList, fmt);
    int size = vprintf(fmt, ArgList);
    if (size > 0)
    {
        char* buffer = (char*)malloc(size + 1);
        if (!buffer) {
            return;
        }
        buffer[size] = 0;
        vsprintf_s(buffer, size + 1, fmt, ArgList);
        memset(buffer, 0, size);
        free(buffer);
    }
}

3.Rust中vector结构：

fn main() {
	let v = Vec::new();
}

vector分两部分，栈上的智能指针（用于内存管理），堆上的实际数据。如果要想将两部分都放在堆上可以使用Box：

alloc:
let b = Box::new(Vec::new());
let p = Box::into_raw(b);			// 这句话表示自己管理内存

free:
let _ = Box::from_raw(parser.original);

4.TLS线程局部存储：

use std::cell::RefCell;
use std::thread;

thread_local!(static FOO: RefCell<u32> = RefCell::new(1));

FOO.with(|f| {
    assert_eq!(*f.borrow(), 1);
    *f.borrow_mut() = 2;
});

// each thread starts out with the initial value of 1
let t = thread::spawn(move|| {
    FOO.with(|f| {
        assert_eq!(*f.borrow(), 1);			// 这里对于基本类型需要解引用，复合类型不需要
        *f.borrow_mut() = 3;
    });
});

// wait for the thread to complete and bail out on panic
t.join().unwrap();

// we retain our original value of 2 despite the child thread
FOO.with(|f| {
    assert_eq!(*f.borrow(), 2);
});

TLS可以在并发的场景下替代全局变量。

避免使用局部变量的方案：

将多个函数定义为成员函数，并使用成员变量作为共享数据介质。