标签 Rust 下的文章 - 记录学习的过程

2022-05-30

Flutter 调用 Rust 生成的共享/静态库日常发病前面写过一两篇使用水文, 用 Rust 写点东西, 编译成 shared/static lib 给 Android 或者 iOS 端调用.这篇水文需要用到之前写得 MD5 的那个 Rust 项目. Android 使用 Rust 生成的动态库用 Rust 开发 iOS 应用(粗糙版) 今天发病的主题是 Flutter FFI 相关.创建 Flutter 项目这里直接通过下面这条命令创建flutter create --platforms=android,ios --template=plugin ffi_demo这里使用的是 plugin 的模板, 如果直接使用 project 模板也是可以的, 现在直接用 Android Studio 打开项目. 我们先来看看项目结构tree -L 1 . ├── CHANGELOG.md ├── LICENSE ├── README.md ├── analysis_options.yaml ├── android ├── example ├── ffi_demo.iml ├── ios ├── lib ├── pubspec.lock ├── pubspec.yaml └── test 5 directories, 7 files处理 Android 端Android 端的比较好处理, 把开头 Android 的那篇文章的 md5 项目生成的动态库拷贝出来, 放到 android/src/main/jniLibs/arm64-v8a 下面, 事实上这里不需要用到 CMakeLists, 所以直接放到 jniLibs 下面, 不过有个问题, Android 项目并不知道你放这边了, 所以还得配置一下 build.gradle 的 sourceSetsandroid { // ... sourceSets { // ... main.jniLibs.srcDirs = ['src/main/jniLibs'] } // ... }这一步完成后, 我们先把 Android 这边的事放一放处理 iOS 端由于之前的 md5 那个项目, 没编译 iOS 的静态库, 所以我们先得把 iOS 静态库生成一下.喜闻乐见的添加对应 target 环节rustup target add aarch64-apple-ios如果你想跑在 Intel 设备的 iOS 仿真器上, 需要添加 x86 的 target, 这里只添加了手机 aarch64 的, 如果你想跑在 M1 设备的 iOS 仿真器上, 你需要添加rustup target add aarch64-apple-ios-sim接着跑到 md5 的项目中运行构造命令cargo build --target aarch64-apple-ios --release构建成功后把 target 目录对应平台的静态库拷贝出来放到 ios/Frameworks 下, 没有 Frameworks 文件夹就自己创建, 文件夹名字随便起, 然后把 ffi_demo.podspec 文件改一下, 总之找到对应的 .podspec 文件, 添加指定静态库的路径Pod::Spec.new do |s| # ... s.vendored_libraries = 'Frameworks/libmd5.a' # ... end处理 Flutter 端上面的准备工作完成后, 我们可以来暴露接口给 Dart 使用啦! 找到 lib/ffi_demo.dart 文件, 修改里面的代码import 'dart:io'; import 'dart:ffi'; // third part package import 'package:ffi/ffi.dart'; typedef LLMD5 = Pointer<Int8> Function(Pointer<Int8>); class FfiDemo { String md5(String str) { final DynamicLibrary nativeLib = Platform.isAndroid ? DynamicLibrary.open("libmd5.so") : DynamicLibrary.process(); LLMD5 md5 = nativeLib.lookupFunction<LLMD5, LLMD5>("ll_md5"); var result = md5(str.toNativeUtf8().cast<Int8>()); return result.cast<Utf8>().toDartString(); } }其实就是把 dart 的字符串转成 C 的字符串传给 md5 函数使用, 返回的结果再转成 dart 的字符串, 我们代码中用到一个第三方包来处理 dart 字符串跟 C 字符串的转换, 直接执行添加第三方包的命令flutter pub add ffi执行 exampleAndroid为了验证我们的插件是否正常工作, 我们把 example 里面的 lib/main.dart 修改一下import 'package:flutter/material.dart'; import 'package:ffi_demo/ffi_demo.dart'; void main() { runApp(const MyApp()); } class MyApp extends StatefulWidget { const MyApp({Key? key}) : super(key: key); @override State<MyApp> createState() => _MyAppState(); } class _MyAppState extends State<MyApp> { String _md5Str = ''; final _ffiDemoPlugin = FfiDemo(); @override void initState() { super.initState(); initMD5(); } void initMD5() { String str = ''; try { str = _ffiDemoPlugin.md5("foo"); } on Exception { str = 'MD5 failed'; } if (!mounted) return; setState(() { _md5Str = str; }); } @override Widget build(BuildContext context) { return MaterialApp( home: Scaffold( appBar: AppBar( title: const Text('Plugin example app'), ), body: Center( child: Text('$_md5Str\n'), ), ), ); } }然后连接对应 ABI 的 Android 手机, 用 Android Studio 执行一下, 可以看到屏幕中间显示了一串经过 md5 运算后的字符串.iOSiOS 这边, 因为我们修改了 podspec 文件, 所以我们需要在 example/ios 目录下执行pod install然后就是更新 xcworkspace, 完成后, 就可以在 Pod 项目中找到我们的静态库了然后用 Android Studio 打开插件项目(直接用 Xcode 执行 Runner 可能会出现找不到符号的问题), 执行到对应的设备(或者仿真器), 就能看到对应的效果Flutter FFI 使用起来比较简单, 某些情况也很有用, 譬如要使用 FFmpeg 理论上可以通过 FFI 来达成我们的目标.

2022年05月30日
209 阅读
0 评论
0 点赞

2022-05-22

2022年05月22日
58 阅读
0 评论
0 点赞

2022-04-25

2022年04月25日
211 阅读
0 评论
0 点赞

2021-02-23

通过 cmake 混合构建 Rust & Cpp Rust 提供了非常好用的 FFI, 可以方便我们将 Rust 代码跟 C/Cpp 之间互操. 在开始之前先弄个基本的种子例子, 我决定还是用 SDL2 来做演示场景. 后续有可能会尝试一下音视频之类的, SDL2 很适合拿来学习.准备工作先把 SDL2 装上, macOS 系统下就访问 brew 中文官网, 可以找到 brew 的安装方法/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)"如果已经安装了 brew, 那就直接安装 sdl2brew install sdl2然后再用 cmake 配置一个 Cpp 项目环境, 没有装 cmake 也可以用 brew 安装brew install cmake接下来就是mkdir rust_client && cd rust_client mkdir gui touch gui/main.cpp touch CMakeLists.txt我们现在开始编辑 CMakeLists.txtcmake_minimum_required(VERSION 3.15) set(SHORT_NAME Sdl2Player) project(${SHORT_NAME}) add_subdirectory(rs) add_subdirectory(gui)然后在 gui 目录下编辑 CMakeLists.txt, 具体 SDL2 目录以自己的环境为准set(CMAKE_CXX_STANDARD 14) include(FindSDL2.cmake) find_package(SDL2 REQUIRED) include_directories(${SDL2_INCLUDE_DIRS}) set(SOURCE main.cpp) add_executable(gui ${SOURCE}) get_target_property(CLIENT_DIR rs LOCATION) target_link_libraries(gui {SDL2_LIBRARIES}) target_link_libraries(gui{CLIENT_DIR}/librs.dylib) add_dependencies(gui rs)这里的 FindSDL2.cmake 是一个 github 上人家的配置文件, 解决找不到 SDL2 的头文件的问题. 可以访问该地址下载 SDL2Test.还有个问题 get_target_property(RS_DIR rs LOCATION) 是后面创建的 Rust 项目里 CMakeLists.txt 定义的, 现在先这样写.然后我们在 main.cpp 里用 SDL2 创建个窗口#include "SDL.h" enum { WINDOW_WIDTH = 960, WINDOW_HEIGHT = 544, SCREEN_CENTER = SDL_WINDOWPOS_CENTERED_MASK, }; int main(int argc, char **argv) { if (SDL_Init(SDL_INIT_VIDEO) < 0) return -1; SDL_Window *window = SDL_CreateWindow("Rust FFI Demo", SCREEN_CENTER, SCREEN_CENTER, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE); if (window == nullptr) return -1; SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, 0); if (renderer == nullptr) return -1; SDL_Event event; while (true) { if (SDL_PollEvent(&event)) { if (SDL_QUIT == event.type) break; SDL_SetRenderDrawColor(renderer, 100, 0, 0, 255); SDL_RenderClear(renderer); SDL_RenderPresent(renderer); } } SDL_DestroyRenderer(renderer); SDL_DestroyWindow(window); SDL_Quit(); return 0; }终于轮到 Rust 项目上场了, 直接在项目根目录下 cargo 走起cargo new --lib rs现在当前项目结构大概长这样$ tree -L 3 . ├── CMakeLists.txt ├── build ├── gui │ ├── CMakeLists.txt │ ├── FindSDL2.cmake │ └── main.cpp └── rs ├── CMakeLists.txt ├── Cargo.lock ├── Cargo.toml ├── src │ └── lib.rs └── target └── debug打开 Cargo.toml 文件编辑一下[package] name = "rs" version = "0.1.0" authors = ["Author <xxx@example.com>"] edition = "2018" [dependencies] [lib] crate-type = ["cdylib"]我们主要关注点 [lib] 下的内容, 添加 crate-type ["cdylib"] 这里意思是说创建 C 动态库, 其实也可以创建静态库, 具体参数是 crate-type = ["cdylib", "staticlib"] 其实也可以指定编译出来的库名字, 譬如指定为 app, 就是添加 name = "app"重点来了, 创建 rs 目录下的 CMakeLists.txt, 添加如下内容if (CMAKE_BUILD_TYPE STREQUAL "Debug") set(CARGO_CMD cargo build) set(TARGET_DIR "debug") else () set(CARGO_CMD cargo build --release) set(TARGET_DIR "release") endif () set(RS_SO "{CMAKE_CURRENT_BINARY_DIR}/{TARGET_DIR}/librs.dylib") add_custom_target(rs ALL COMMENT "Compiling rs module" COMMAND CARGO_TARGET_DIR={CMAKE_CURRENT_BINARY_DIR}{CARGO_CMD} COMMAND cp {RS_SO}{CMAKE_CURRENT_BINARY_DIR} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) set_target_properties(rs PROPERTIES LOCATION ${CMAKE_CURRENT_BINARY_DIR}) add_test(NAME rs_test COMMAND cargo test WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})现在为了保证项目干净整洁, 我们可以在项目根目录创建个 build, 然后再用 cmake 生成 make filemkdir build && cd build cmake .. make ./gui/gui看看效果, 我看到的效果是一个暗红色空白窗口. 好了现在整个项目算了配置完成了.Cpp 调用 Rust通常我们学习当然是从 Hello World 开始的啦, 那就用控制台打印一下吧. 编辑 Rust src 下的 lib.rs 文件#[no_mangle] pub extern "C" fn hello_rust() { println!("Hello Rust!"); }日常 Hello Rust, no_mangle 保证函数签名不被混淆, 这一步很重要, 不然 Cpp 调用的时候就会找不到对应的函数, 然后我们用 Cpp 调用一下.// ... #include "rust.hpp" // ... int main(int argc, char **argv) { // ... bool quit = true; while (quit) { if (SDL_PollEvent(&event)) { if (SDL_QUIT == event.type) break; if (SDL_KEYDOWN == event.type) { switch (event.key.keysym.sym) { case SDLK_ESCAPE: quit = false; break; case SDLK_j: hello_rust(); break; } } // ... } } // ... return 0; }肯定注意到有个 #include "rust.hpp", 原来是把 hello_rust 函数 extern 出来// rust.hpp extern "C" { void hello_rust(); };然后在 SDL 主线程事件循环中通过键盘字母 j 触发调用, 也稍微改了点退出的逻辑. 最后别忘了在 gui 目录下 CMakeLists.txt 中修改一下 SOURCE# ... set(SOURCE rust.hpp main.cpp) # ...最后重复构建操作cd build cmake .. make执行一下看看效果, 只要按了字母 j 就会在控制台打印 Hello Rust! 看样子简单的 Cpp 调用 Rust 完成了.项目地址https://github.com/limitLiu/cpp-with-rust.git

2021年02月23日
53 阅读
0 评论
0 点赞

2021-02-23

Rust 数据结构-动手实现 Vec 正文讲屁话阶段Rust 的 Vec 其实是动态数组, 很多语言内置动态数组, 譬如 JavaScript Python这类, 像 Rust 这种具有内存控制能力的语言, 就选择了标准库内置动态数组.基本用法let mut v1 : Vec<i32> = vec![]; dbg!(v1.len(), v1.capacity()); for i in 1..10 { v1.push(i); } dbg!(&v1);布局现在直接写一下 Rust 动态数组直观实现pub struct MyVec<T> { ptr: *mut T, cap: usize, len: usize, }这样直接编译能通过, 但是 ptr 这个裸指针不能让 Drop check 正常工作, 因为直接在这里使用裸指针 Drop 检查器会认为你没有持有任何值, 因此我们可以用 Unique<T> 处理祼指针 *mut T, 通过它内部的 PhantomData 来帮助 Drop check 工作.Unique<T> 可以封装祼指针T 是可变的可以进行 drop 检查T 实现了 Send/Sync, 该指针也具备 Send/Sync 特性, 等于讲线程安全指针具备非空性既然如此自己实现一个吧, 解析源码自己写不会浪费什么时间, 还能体会别人的设计, 顺道实现一下 Send/Syncuse std::marker::PhantomData; struct MyUnique<T: ?Sized> { ptr: *const T, _marker: PhantomData<T>, } unsafe impl<T: Send + ?Sized> Send for MyUnique<T> {} unsafe impl<T: Sync + ?Sized> Sync for MyUnique<T> {} impl<T: ?Sized> MyUnique<T> { #[inline] pub fn new(ptr: *mut T) -> Option<Self> { if !ptr.is_null() { Some(unsafe { MyUnique { ptr: ptr as _, _marker: PhantomData, } }) } else { None } } #[inline] pub const fn as_ptr(&self) -> *mut T { self.ptr as *mut T } }我们看到有个 ?Sized 的 trait bound 这玩意其实是指定一下泛型的特性, 意思是指编译时确定大小, 默认情况下直接写 T 就是 Sized 了, 加了个问号就会放宽约束的范围, 编译时不确定大小的也被接受. 加上 #[inline] 这个属性就表示内联函数, 因为这几个函数可能会经常使用到, 内联会带点加速效果.内存分配之后我们要考虑初始化容器了, 如果容器放了东西肯定会开辟内存空间, 但是初始化的情况容器应该是空的, 既然是空的肯定不会分配内存, 那就用 MyUnique 建个空的东西imp<T: ?Sized> MyUnique<T> { #[inline] pub const unsafe fn new_unchecked(ptr: *mut T) -> Self { MyUnique { ptr: ptr as _, _marker: PhantomData, } } } impl<T> MyUnique<T> { pub const fn empty() -> Self { unsafe { MyUnique::new_unchecked(mem::align_of::<T>() as *mut T) } } } pub struct MyVec<T> { ptr: MyUnique<T>, cap: usize, len: usize, } impl<T> MyVec<T> { fn new() -> Self { assert_ne!(mem::size_of::<T>(), 0, "We're not ready to handle ZSTs"); MyVec { ptr: MyUnique::empty(), len: 0, cap: 0, } } }接下来写一下内存分配相关的代码, 既然我们需要分配内存, 这块其实没什么东西, 就是读一下内存分配的文档然后使用起来, 当然也要考虑对齐. 其实这是个扩容处理use std::alloc::{handle_alloc_error, realloc, Layout}; use std::mem; impl<T> MyVec<T> { fn grow(&self) -> Self { unsafe { let (new_cap, ptr) = if self.cap == 0 { let ptr = alloc(Layout::array::<T>(1).unwrap()); (1, ptr) } else { let new_cap = self.cap * 2; let layout = Layout::array::<T>(self.cap).unwrap(); let ptr = realloc(self.ptr.as_ptr() as *mut _, layout, layout.size()); if ptr.is_null() { handle_alloc_error(Layout::from_size_align_unchecked( new_cap * elem_size, mem::align_of::<T>(), )); } (new_cap, ptr) }; Self { ptr: MyUnique::new_unchecked(ptr as *mut _), cap: new_cap, len: self.len, } } } }push & pop上面已经做到能分配内存了, 接下来自然是实现基本的功能.先分析一波 push 的行为, push 就是往动态数组添加元素, 如果满了就需要重新分配内存, 其实就是调用 grow, 每次添加元素后长度也要相应 +1, 还需要对相应地址写元素. 写入行为用 std::ptr 的 write 函数来处理, 相应的 pop 也很好理解, 只要把最后一个读取出来同时把长度 -1use std::{mem, ptr}; impl<T> MyVec<T> { pub fn ptr(&self) -> *mut T { self.ptr.as_ptr() } pub fn push(&mut self, element: T) { if self.len == self.cap { self.grow(); } unsafe { ptr::write(self.ptr().add(self.len), element); } self.len += 1; } pub fn pop(&mut self) -> Option<T> { if self.len == 0 { None } else { self.len -= 1; unsafe { Some(ptr::read(self.ptr().add(self.len))) } } } }回收资源Rust 的机制让我们处理这个问题非常简单, 只需要实现一下 trait Dropimpl<T> Drop for MyVec<T> { fn drop(&mut self) { let elem_size = mem::size_of::<T>(); if elem_size != 0 { while let Some(_) = self.pop() {} unsafe { dealloc(self.ptr() as *mut _, Layout::array::<T>(self.cap).unwrap()); } } } }解引用至此, 已经实现了一个简单的数据结构, 但是我们还没法跟 slice 相通, 真实的 Vec 不是这样的, 所以当下我们应该实现一下自动解引用, 只要实现了下面这些东西, 我们就可以用 slice 的提供的接口了use std::ops::{Deref, DerefMut}; impl<T> Deref for MyVec<T> { type Target = [T]; fn deref(&self) -> &[T] { unsafe { std::slice::from_raw_parts(self.ptr(), self.len) } } } impl<T> DerefMut for MyVec<T> { fn deref_mut(&mut self) -> &mut [T] { unsafe { std::slice::from_raw_parts_mut(self.ptr(), self.len) } } }插入跟删除插入插入的行为其实就是把当前要插入的位置之后的所有元素分别向右移动一位, 譬如一个数组 [1, 2, 3], 我要把 10 插入索引 1 位置(就是元素 2), 那么 10 的下标就是 1, 同时元素 2 跟 3 的下标就是 2 跟 3, 最后就变成了 [1, 10, 2, 3].impl<T> MyVec<T> { // ... pub fn insert(&mut self, index: usize, element: T) { if self.cap == self.len { self.grow(); } unsafe { if index < self.len { ptr::copy(self.ptr().add(index), self.ptr().add(index + 1), self.len - index); } ptr::write(self.ptr().add(index), element); self.len += 1; } } }删除删除的行为也很好理解, 跟插入反着来就可以了, 只要把要删除的位置之后所有的下标向左移动一位, 譬如现在把之前插入后的数组 [1, 10, 2, 3] 10 给删除掉, 10 所在的下标是 1, 后面的元素的下标分别是 2 跟 3, 后面的 -1 就完成了.impl<T> MyVec<T> { // ... pub fn remove(&mut self, index: usize) -> T { assert!(index < self.len, "index out of bounds"); unsafe { self.len -= 1; let result = ptr::read(self.ptr().add(index)); ptr::copy(self.ptr().add(index + 1), self.ptr().add(index), self.len - index); result } } }IntoIter这趟开始处理一下 Vec 才有的迭代器, 其实只要实现了自动解引用的 trait, 就可以使用 slice 的 iter 还有 iter_mut, 但是 slice 是没有 into_iter 的, 所以我们得实现一下.现在有个问题, 既然已经有了 slice 的迭代器功能了, 我们为什么要实现这个 IntoIter?我们可以看到一个 Vec 可以直接用 for 进行循环遍历, 原因就是只要一个自定义的类型实现了 IntoIter 就具备能被 for 迭代的能力let v = vec![1, 2, 3]; for i in v { dbg!(i); }现在可以用两个指针来处理迭代器的操作, 一个在开头, 一个在结尾后面那一个, 只要开头的指针跟结尾后一个的指针地址相同, 就表明迭代结束了.[1, 2, 3, 4, 5, sth] ^ ^ start end现在来建立个迭代器结构, 大概长这样struct IntoIter<T> { start: *const T, end: *const T, }当然后续还要处理内存相关的, 所以我们应该把 Vec 分配的空间讯息保存一下, 当然还要把 MyVec 转化成 IntoIter 类型struct IntoIter<T> { start: *const T, end: *const T, buf: MyUniuqe<T>, cap: usize, } impl<T> MyVec<T> { fn into_iter(self) -> IntoIter<T> { let MyVec { ptr, cap, len } = self; mem::forget(self); unsafe { IntoIter { buf: ptr, cap, start: ptr.as_ptr(), end: if cap == 0 { ptr.as_ptr() } else { ptr.as_ptr().add(len) }, } } } }还要实现一下迭代器, size_hint 是仿写标准库的, 主要作用是表达剩余可迭代元素数量上下界, 下面是 next 相关的操作 impl<T> Iterator for IntoIter<T> { type Item = T; fn next(&mut self) -> Option<T> { if self.start == self.end { None } else { unsafe { let result = ptr::read(self.start); self.start = self.start.offset(1); Some(result) } } } fn size_hint(&self) -> (usize, Option<usize>) { let len = (self.end as usize - self.start as usize) / mem::size_of::<T>(); (len, Some(len)) } }还有 next_back 的操作 impl<T> DoubleEndedIterator for IntoIter<T> { fn next_back(&mut self) -> Option<T> { if self.start == self.end { None } else { unsafe { self.end = self.end.offset(-1); Some(ptr::read(self.end)) } } } }为了处理内存相关的, 我们要给 IntoIter 实现一下 Drop traitimpl<T> Drop for IntoIter<T> { fn drop(&mut self) { if self.cap != 0 { for _ in &mut *self {} unsafe { dealloc(self.buf.as_ptr() as *mut _, Layout::array::<T>(self.cap).unwrap()); } } } }RawVec现在继续重构代码, 因为我们分别给 IntoIter 跟 MyVec 实现了一遍 Drop, 所以重构一下代码是有必要的pub struct MyVec<T> { buf: RawVec<T>, len: usize, } impl<T> MyVec<T> { pub fn push(&mut self, element: T) { if self.len == self.cap() { self.buf.grow(); } unsafe { ptr::write(self.ptr().add(self.len), element); } self.len += 1; } pub fn pop(&mut self) -> Option<T> { if self.len == 0 { None } else { self.len -= 1; unsafe { Some(ptr::read(self.ptr().add(self.len))) } } } pub fn insert(&mut self, index: usize, element: T) { assert!(index <= self.len, "index out of bounds"); if self.cap() == self.len { self.buf.grow(); } unsafe { if index < self.len { ptr::copy(self.ptr().add(index), self.ptr().add(index + 1), self.len - index); } ptr::write(self.ptr().add(index), element); self.len += 1; } } pub fn remove(&mut self, index: usize) -> T { assert!(index < self.len, "index out of bounds"); unsafe { self.len -= 1; let result = ptr::read(self.ptr().add(index)); ptr::copy(self.ptr().add(index + 1), self.ptr().add(index), self.len - index); result } } } impl<T> Drop for MyVec<T> { fn drop(&mut self) { while let Some(_) = self.pop() {} } } struct IntoIter<T> { start: *const T, end: *const T, _buf: RawVec<T>, } impl<T> Iterator for IntoIter<T> { type Item = T; fn next(&mut self) -> Option<T> { if self.start == self.end { None } else { unsafe { let result = ptr::read(self.start); self.start = self.start.offset(1); Some(result) } } } fn size_hint(&self) -> (usize, Option<usize>) { let len = (self.end as usize - self.start as usize) / mem::size_of::<T>(); (len, Some(len)) } } impl<T> DoubleEndedIterator for IntoIter<T> { fn next_back(&mut self) -> Option<T> { if self.start == self.end { None } else { unsafe { self.end = self.end.offset(-1); Some(ptr::read(self.end)) } } } } impl<T> Drop for IntoIter<T> { fn drop(&mut self) { for _ in &mut *self {} } } struct RawVec<T> { ptr: MyUnique<T>, cap: usize, } impl<T> RawVec<T> { fn new() -> Self { RawVec { ptr: MyUnique::empty(), cap: 0, } } fn grow(&self) -> Self { unsafe { let (new_cap, ptr) = if self.cap == 0 { let ptr = alloc(Layout::array::<T>(1).unwrap()); (1, ptr) } else { let new_cap = self.cap * 2; let layout = Layout::array::<T>(self.cap).unwrap(); let ptr = realloc(self.ptr.as_ptr() as *mut _, layout, layout.size()); if ptr.is_null() { handle_alloc_error(Layout::from_size_align_unchecked( new_cap * mem::size_of::<T>(), mem::align_of::<T>(), )); } (new_cap, ptr) }; Self { ptr: MyUnique::new_unchecked(ptr as *mut _), cap: new_cap, } } } } impl<T> Drop for RawVec<T> { fn drop(&mut self) { if self.cap != 0 { unsafe { dealloc(self.ptr.as_ptr() as *mut _, Layout::array::<T>(self.cap).unwrap()); } } } }抽取迭代操作现在我们基本的 Vec 结构已经做出来了, 现在仿照之前的 RawVec 做一份封装.struct RawValIter<T> { start: *const T, end: *const T, } impl<T> RawValIter<T> { unsafe fn new(slice: &[T]) -> Self { RawValIter { start: slice.as_ptr(), end: if slice.len() == 0 { slice.as_ptr() } else { slice.as_ptr().offset(slice.len() as isize) }, } } } impl<T> Iterator for RawValIter<T> { type Item = T; fn next(&mut self) -> Option<T> { if self.start == self.end { None } else { unsafe { let result = ptr::read(self.start); self.start = self.start.offset(1); Some(result) } } } fn size_hint(&self) -> (usize, Option<usize>) { let len = (self.end as usize - self.start as usize) / mem::size_of::<T>(); (len, Some(len)) } } impl<T> DoubleEndedIterator for RawValIter<T> { fn next_back(&mut self) -> Option<T> { if self.start == self.end { None } else { unsafe { self.end = self.end.offset(-1); Some(ptr::read(self.end)) } } } }然后改造一下迭代器, 现在只要在各函数内部调用 RawValIter 的实现就行了struct IntoIter<T> { _buf: RawVec<T>, iter: RawValIter<T>, } impl<T> Drop for MyVec<T> { fn drop(&mut self) { while let Some(_) = self.pop() {} } } impl<T> Iterator for IntoIter<T> { type Item = T; fn next(&mut self) -> Option<T> { self.iter.next() } fn size_hint(&self) -> (usize, Option<usize>) { self.iter.size_hint() } } impl<T> DoubleEndedIterator for IntoIter<T> { fn next_back(&mut self) -> Option<T> { self.iter.next_back() } } impl<T> Drop for IntoIter<T> { fn drop(&mut self) { for _ in &mut self.iter {} } }处理 Zero-Sized Types通常情况下, Rust 是不需要处理 Zero-Sized Types 的, 但是现在我们的代码中有大量关于裸指针的操作, 假如给分配器传递 zst, 会导致未定义行为, 对 zst 裸指针进行 offset 是一个 no-op 行为.先把 new 函数的 cap 处理一下, 如果是 size_of 处理出来的 T 是 0 的情况, 就给 0 按位取反(usize::MAX), 因为 T 的 size_of 为 0 其实不需要开辟内存, 反正你存进来的都是 0, 逻辑上不会占用内存.impl<T> RawVec<T> { fn new() -> Self { let cap = if mem::size_of::<T>() == 0 { !0 } else { 0 }; RawVec { ptr: MyUnique::empty(), cap, } } }然后就是 grow 函数也处理一下impl<T> RawVec<T> { // ... fn grow(&self) -> Self { unsafe { let elem_size = mem::size_of::<T>(); assert_ne!(elem_size, 0, "capacity overflow"); let (new_cap, ptr) = if self.cap == 0 { let ptr = alloc(Layout::array::<T>(1).unwrap()); (1, ptr) } else { let new_cap = self.cap * 2; let layout = Layout::array::<T>(self.cap).unwrap(); let ptr = realloc(self.ptr.as_ptr() as *mut _, layout, layout.size()); (new_cap, ptr) }; if ptr.is_null() { handle_alloc_error(Layout::from_size_align_unchecked( new_cap * elem_size, mem::align_of::<T>(), )); } Self { ptr: MyUnique::new_unchecked(ptr as *mut _), cap: new_cap, } } } }RawVec 的 Drop 也需要处理, 其实之前的实现也可以, 但是假装对齐一下吧!impl<T> Drop for RawVec<T> { fn drop(&mut self) { let elem_size = mem::size_of::<T>(); if self.cap != 0 && elem_size != 0 { unsafe { dealloc( self.ptr.as_ptr() as *mut _, Layout::from_size_align_unchecked(self.cap * elem_size, mem::align_of::<T>()), ); } } } }然后是 RawValIter 的 zst 处理impl<T> RawValIter<T> { unsafe fn new(slice: &[T]) -> Self { RawValIter { start: slice.as_ptr(), end: if mem::size_of::<T>() == 0 { ((slice.as_ptr() as usize) + slice.len()) as *const _ } else if slice.len() == 0 { slice.as_ptr() } else { slice.as_ptr().offset(slice.len() as isize) }, } } }迭代器也处理一下, size_hint 除数为 0 的情况需要处理impl<T> Iterator for RawValIter<T> { type Item = T; fn next(&mut self) -> Option<T> { if self.start == self.end { None } else { unsafe { let result = ptr::read(self.start); self.start = if mem::size_of::<T>() == 0 { (self.start as usize + 1) as *const _ } else { self.start.offset(1) }; Some(result) } } } fn size_hint(&self) -> (usize, Option<usize>) { let elem_size = mem::size_of::<T>(); let len = (self.end as usize - self.start as usize) / (if elem_size == 0 { 1 } else { elem_size }); (len, Some(len)) } } impl<T> DoubleEndedIterator for RawValIter<T> { fn next_back(&mut self) -> Option<T> { if self.start == self.end { None } else { unsafe { self.end = if mem::size_of::<T>() == 0 { (self.end as usize - 1) as *const _ } else { self.end.offset(-1) }; Some(ptr::read(self.end)) } } } }with_capacity这个实现一下差不多算结束了, 先把 MyVec 改一下impl<T> MyVec<T> { // ... pub fn with_capacity(capacity: usize) -> MyVec<T> { MyVec { buf: RawVec::with_capacity(capacity), len: 0 } } }然后给 RawVec 添加个接口impl<T> RawVec<T> { fn new() -> Self { let cap = if mem::size_of::<T>() == 0 { !0 } else { 0 }; RawVec { ptr: MyUnique::empty(), cap, } } pub fn with_capacity(cap: usize) -> Self { RawVec::allocate_in(cap, None) } fn allocate_in(cap: usize, p: Option<MyUnique<T>>) -> Self { unsafe { let elem_size = mem::size_of::<T>(); assert_ne!(elem_size, 0, "capacity overflow"); let (new_cap, ptr) = if cap == 0 { let ptr = alloc(Layout::array::<T>(1).unwrap()); (1, ptr) } else { if let Some(some_p) = p { let new_cap = cap * 2; let layout = Layout::array::<T>(cap).unwrap(); let ptr = realloc(some_p.as_ptr() as *mut _, layout, layout.size()); (new_cap, ptr) } else { let ptr = alloc(Layout::array::<T>(cap).unwrap()); (cap, ptr) } }; if ptr.is_null() { handle_alloc_error(Layout::from_size_align_unchecked( new_cap * elem_size, mem::align_of::<T>(), )); } Self { ptr: MyUnique::new_unchecked(ptr as *mut _), cap: new_cap, } } } fn grow(&self) -> Self { RawVec::allocate_in(self.cap, Some(self.ptr)) } }现在已经把 grow 抽取出来, 同时给 with_capacity 调用Drain目前待定吧, 这个稍微麻烦点, 还没想好怎么讲.Git 托管最后把代码放上来https://e.coding.net/limitLiu/algorithms-with-rust.git

2021年02月23日
21 阅读
0 评论
0 点赞