Bitmap.LockBits 中 ImageLockMode 的用途是什么？\n对于 ReadOnly，文档仅说明
\n\n\n\n\nReadOnly：指定图像的一部分被锁定以供读取。
\n
但下面的代码证明，这不是真的。\n我知道这个问题之前已经被问过，这次我尝试使用一些实际的代码，因为我在其他地方找不到答案。
\n\n如果我运行以下代码，它的行为与答案中所解释的完全一样。
\n\nusing System;\nusing System.Drawing;\nusing System.Drawing.Imaging;\nusing System.Runtime.InteropServices;\n\nnamespace LockBits_Trials\n{\n class Program\n {\n static readonly Random rnd = new Random(42);\n static void Main(string[] args)\n {\n Bitmap bmp_fromFile = new Bitmap("example.png");\n Bitmap bmp_fromCtor = new Bitmap(100, 100, PixelFormat.Format24bppRgb);\n marshalCopy(bmp_fromFile, "result_marshalCopy_fromFile.png");\n marshalCopy(bmp_fromCtor, "result_marshalCopy_fromCtor.png");\n usePointer(bmp_fromFile, "result_usePointer_fromFile.png");\n usePointer(bmp_fromCtor, "result_usePointer_fromCtor.png");\n }\n\n private static unsafe void usePointer(Bitmap bmp, string filename)\n {\n ImageLockMode mode = ImageLockMode.ReadOnly;\n //code from turgay at http://csharpexamples.com/fast-image-processing-c/ \n if (bmp.PixelFormat != …众所周知，使用sun.misc.Unsafe#allocateInstance它可以创建一个对象，而无需调用任何类构造函数。
是否可以做相反的事情：给定一个现有实例，调用它的构造函数？
澄清：这不是关于我在生产代码中要做的事情的问题。我对 JVM 内部结构和仍然可以完成的疯狂事情感到好奇。欢迎特定于某些 JVM 版本的答案。
在 C# 中，您不应该能够创建指向托管类型的指针，但通过此 API，您可以使用Unsafe.AsPointer<T>.
https://www.nuget.org/packages/System.Runtime.CompilerServices.Unsafe/
我使用 ILSpy 查看源代码，看到了以下内容：
[MethodImpl(MethodImplOptions.AggressiveInlining)]
[System.Runtime.Versioning.NonVersionable]
public unsafe static void* AsPointer<T>(ref T value)
{
return &value;
}
还有其他类似的API：
//Unity.Collections.LowLevel.Unsafe.UnsafeUtility
public unsafe static T ReadArrayElement<T>(void* source, int index)
{
return *(T*)((byte*)source + index * sizeof(T));
}
这是如何运作的以及如何复制这种行为？
考虑以下：
// 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) …我有一个独特的场景，我想在其中f64用作HashMap. 特别是我知道f64永远不会NaN并且我可以容忍f64应该相等但不是。所以，我transmute()的f64到u64。然而，当我拉u64出来HashMap和transmute()这回f64它是一个不同的值。下面和操场上的代码。
use std::collections::HashMap;
fn main() {
let x = 5.0;
let y: u64 = unsafe { std::mem::transmute(x) };
let x: f64 = unsafe { std::mem::transmute(y) };
println!("y: {}, x: {}", y, x);
let mut hash = HashMap::new();
hash.insert(y, 8);
for (y, _) in &hash {
let x: f64 = unsafe { std::mem::transmute(y) }; …我正在使用两个独立的功能。
// This structure is not `Clone`.
struct MyStruct;
fn take_owned(s: MyStruct) -> MyStruct {
// Do things
s
}
fn take_mut(s: &mut MyStruct) {
*s = take_owned(s /* problem */);
}
我想了一个解决方案，但我不确定它是否合理：
use std::ptr;
// Temporarily turns a mutable reference into an owned value.
fn mut_to_owned<F>(val: &mut MyStruct, f: F)
where
F: FnOnce(MyStruct) -> MyStruct,
{
// We're the only one able to access the data referenced by `val`.
// This operation simply takes ownership of the …假设您有 的Vec实例的两个集合（此处为简单起见）T，以及一个用于计算这些集合中的元素是否出现在其中一个或两个集合中的函数：
// With lifetimes not yet annotated
fn comm(left: &Vec<T>, right: &Vec<T>) -> Vec<(Tag, &T)> {}
enum Tag {
Left,
Both,
Right,
}
comm(l,r) 保证返回的引用指向left集合的元素，无论T是出现在leftonly中还是 T出现在 Both 中。
然而，因为有些T可能出现在rightonly 中，所以函数的完整签名必须如下所示：
fn comm<'a, 'b, 'c>(left: &'a Vec<T>, right: &'b Vec<T>) -> Vec(Tag, &'c T)
where
'a: 'c,
'b: 'c,
(tag, &T)那么，实际的问题是：我知道，在返回的元组之一中comm， if tag == Left or tag == Both, …
浏览 std::cell::Cell 的文档，我没有看到如何检索对内部数据的非可变引用。只有get_mut方法：https://doc.rust-lang.org/std/cell/struct.Cell.html#method.get_mut
我不想使用这个函数，因为我想&self用&self mut.
我找到了采用原始指针的替代解决方案：
use std::cell::Cell;
struct DbObject {
key: Cell<String>,
data: String
}
impl DbObject {
pub fn new(data: String) -> Self {
Self {
key: Cell::new("some_uuid".into()),
data,
}
}
pub fn assert_key(&self) -> &str {
// setup key in the future if is empty...
let key = self.key.as_ptr();
unsafe {
let inner = key.as_ref().unwrap();
return inner;
}
}
}
fn main() {
let obj = DbObject::new("some data...".into());
let key …在 Linux 上，该文件/var/run/utmp包含多个utmp结构，每个结构都是原始二进制格式，在一个文件中彼此跟随。utmp本身就比较大（我的机器上是384字节）。我正在尝试读取该文件的原始数据，并在数据有意义后实施检查。我对 Rust 并不陌生，但这是我第一次真正体验到事物不安全的一面。
我有一个包含多个 c 的文件sturct utmp（文档）。在 Rust 中，我想将整个文件读入Vec<libc::utmpx>. 更具体地说，如果读者打开该文件，我该如何阅读struct utmp？
下面是 的三种不同实现read_raw，它接受一个 reader 并返回一个RawEntry（我的 别名struct utmp）。哪种方法最正确？我正在尝试编写尽可能高性能的代码，并且我担心read_raw0如果涉及 memcpys，可能会比其他代码慢。完成此行为的最佳/最快方法是什么？
use std::io::Read;
use libc::utmpx as RawEntry;
const RawEntrySize = std::mem::size_of::<RawEntry>();
type RawEntryBuffer = [u8; RawEntrySize];
/// Read a raw utmpx struct
// After testing, this method doesn't work
pub fn read_raw0<R: Read>(reader: &mut R) -> …将对强的transmute共享引用转换为对a的共享引用是否安全？&Arc<T>&Weak<T>
换个角度问：以下安全功能是否健全，或者是否存在等待发生的漏洞？
pub fn as_weak<'a, T>(strong: &'a Arc<T>) -> &'a Weak<T> {
unsafe { transmute::<&'a Arc<T>, &'a Weak<T>>(strong) }
}
我们有一个返回 a 的现有函数&Weak<T>。内部数据结构发生了一些变化，我现在有了一个Arc<T>以前有过的Weak<T>，但我需要保持 semver 与该函数接口的兼容性。如果不需要的话，我宁愿避免Weak<T>仅仅为了这个功能而需要存储实际的副本。
Arc<T>和的底层内存表示是相同的：指向内部结构的Weak<T>非空指针（或类似指针的值） ，其中包含强引用计数和弱引用计数以及内部值。Weak::new()ArcInnerT
Arc<T>还包含 a PhantomData<T>，但我的理解是，如果这改变了任何东西，它只会适用于 drop，这与这里的情况无关，因为我们只是改变共享引用，而不是拥有的值。
an 将对其内部指针执行的操作Arc<T>可能是 a 可能执行的操作的超集Weak<T>，因为它们具有相同的表示形式，但Arc保证内部T值仍然有效，而 whileWeak则不然。
鉴于这些事实，在我看来，一切都不会出错。但是，我以前没有编写过太多unsafe代码，也从未编写过这样的生产案例。我不确定我是否完全理解可能出现的问题。这种嬗变是否安全可靠，还是还有其他需要考虑的因素？