Comment créer un type? Sized à partir d'un pointeur brut?

Question

Voici un exemple de transmuter un type Sized d'un pointeur brut:

use std::mem; 

#[derive(Eq, PartialEq)] 
#[repr(packed)] 
struct Bob { 
    id: u32, 
    age: u32, 
} 

unsafe fn get_type<'a, T: Sized>(p: *const u8) -> &'a T { 
    mem::transmute(p) 
} 

#[test] 
fn it_works() { 
    let bob = Bob { 
     id: 22, 
     age: 445, 
    }; 
    let bob2: &Bob = unsafe { 
     let ptr: *const u8 = mem::transmute(&bob); 
     get_type(ptr) 
    }; 
    assert_eq!(&bob, bob2); 
} 

Cependant, pour ma demande, je veux être en mesure d'obtenir un type ?Sized au lieu d'un type Sized. Cependant, cela ne fonctionne pas:

unsafe fn get_type2<'a, T: ?Sized>(p: *const u8) -> &'a T { 
    mem::transmute(p) 
} 

Il échoue avec ce message d'erreur:

error: transmute called with differently sized types: *const u8 (64 bits) to &'a T (pointer to T) [--explain E0512] 
--> src/main.rs:2:9 
    |> 
2 |>   mem::transmute(p) 
    |>   ^^^^^^^^^^^^^^ 

J'ai essayé de lui donner un &[u8] (pointeur de la graisse) en le convertissant en utilisant std::slice::from_raw_parts, mais il échoue avec à peu près le même message d'erreur.

Answer 1

Vous ne pouvez pas réellement pour la raison même citée dans le message d'erreur.

références de rouille peuvent être soit de taille pointeur (pour Sized types) ou plus gros (pour !Sized types). Par exemple, si Trait est un trait, une référence &Trait est en fait deux champs tels que définis par std::raw::TraitObject.

Ainsi, afin de former une référence à un type non collé, vous devez:

• identifier exactement quel genre de type il est non encollé (? Trait tranche ...)
• ramasser la représentation droite (std::raw::TraitObject, std::raw::Slice, ...)

et vous devez remplir les espaces vides (il est plus qu'un simple pointeur). Donc, à moins que vous ne puissiez limiter votre fonction à &T where T: Sized, vous ne pouvez pas simplement transformer un pointeur brut en &T.