unsafe

问题 I have a C DLL that I'm writing a C# interop class for. In the C DLL, one of the key methods fills a 2d structure; the structure is allocated and freed by helper methods, like so: // Simple Struct Definition -- Plain Old Data typedef struct MyPodStruct_s { double a; double b; } MyPodStruct; typedef struct My2dArray_s { MyPodStruct** arr; // allocated by Init2d; // array of arrays. // usage: arr[i][j] for i<n,j<m int n; int m; } My2dArray; void Init2d(My2dArray* s, int n, int m); void Free2d

问题 I don't understand why Pipes are said unsafe when there are multiple senders and receivers. How the following code can be turned into code using Queues if this is the case ? Queues don't throw EOFError when closed, so my processes can't stop. Should I send endlessly 'Poison' messages to tell them to stop (this way, i'm sure all my processes receive at least one poison) ? I would like to keep the pipe p1 open until I decide otherwise (here it's when I have sent the 10 messages). from

问题 I am using tikv/raft-rs library for implementing a consensus system. This library has a RawNode object which is a thread-unsafe object. We must execute some functions on this object periodically (example), hence I use a new thread for executing. Here are the constraints: I need to have this object on the main-thread doesn't have this object for accessing some its internal states. (e.g.: raw_node.is_leader ) This object must be accessed on a worker thread. Because of these constraints, this

问题 Is there any way to achieve undefined behavior in Rust without using unsafe ? Of course, such behavior can be wrapped by a third-party library in a "safe" function so let's assume we're using only the standard one. 回答1: Absolutely, but any such case is a bug with Rust or the standard libary. My favorite example is LLVM loop optimization can make safe programs crash, which actually occurs due to a poor interaction of Rust and LLVM semantics: pub fn oops() { (|| loop { drop(42) })() } Compiled

问题 I am trying to understand the problems with duplicated code for & and &mut in getter-type functions. I'm trying to understand whether a particular solution to this problem using a cast inside an unsafe block would be safe. The following is an example of the problem. It is taken from the really nice tutorial Learning Rust With Entirely Too Many Linked Lists. type Link<T> = Option<Box<Node<T>>>; pub struct List<T> { head: Link<T>, } struct Node<T> { elem: T, next: Link<T>, } impl<T> List<T> { /

问题 Consider the following: // Just a sequence of adjacent fields of same the type #[repr(C)] #[derive(Debug)] struct S<T> { a : T, b : T, c : T, d : T, } impl<T : Sized> S<T> { fn new(a : T, b : T, c : T, d : T) -> Self { Self { a, b, c, d, } } // reinterpret it as an array fn as_slice(&self) -> &[T] { unsafe { std::slice::from_raw_parts(self as *const Self as *const T, 4) } } } fn main() { let s = S::new(1, 2, 3, 4); let a = s.as_slice(); println!("s :: {:?}\n\ a :: {:?}", s, a); } Is this code

问题 Consider the following: // Just a sequence of adjacent fields of same the type #[repr(C)] #[derive(Debug)] struct S<T> { a : T, b : T, c : T, d : T, } impl<T : Sized> S<T> { fn new(a : T, b : T, c : T, d : T) -> Self { Self { a, b, c, d, } } // reinterpret it as an array fn as_slice(&self) -> &[T] { unsafe { std::slice::from_raw_parts(self as *const Self as *const T, 4) } } } fn main() { let s = S::new(1, 2, 3, 4); let a = s.as_slice(); println!("s :: {:?}\n\ a :: {:?}", s, a); } Is this code

来源： https://stackoverflow.com/questions/58977260/is-it-safe-to-send-struct-containing-rc-if-strong-count-is-1-and-weak-count

问题 I have the following struct struct Test; impl Test { async fn function(&mut self) {} } I want to implement an std::future::Future (well, actually futures::Stream , but it's basically the same) on Test , that would poll the function . My first try looked something like this impl Future for Test { type Output = (); fn poll(self: Pin<&mut self>, cx: &mut Context<'_>) -> Poll<Self::Output> { match self.function() { Poll::Pending => Poll::Pending, Poll::Ready(_) => Poll::Ready(()), } } } Obviously

问题 I have the following struct struct Test; impl Test { async fn function(&mut self) {} } I want to implement an std::future::Future (well, actually futures::Stream , but it's basically the same) on Test , that would poll the function . My first try looked something like this impl Future for Test { type Output = (); fn poll(self: Pin<&mut self>, cx: &mut Context<'_>) -> Poll<Self::Output> { match self.function() { Poll::Pending => Poll::Pending, Poll::Ready(_) => Poll::Ready(()), } } } Obviously