La version 1.82 du langage de programmation généraliste Rust, initialement développée par Mozilla et maintenant maintenue par la Rust Foundation, une organisation à but non lucratif indépendante, a été publiée. Ce langage se concentre sur la sécurité en mémoire et offre des outils pour un haut niveau de parallélisme dans l'exécution des tâches, sans avoir besoin d'un ramasse-miettes ni d'un environnement d'exécution (ce dernier se limite à une initialisation de base et à un support pour la bibliothèque standard).
Les méthodes de gestion de la mémoire en Rust éliminent les erreurs lors de la manipulation des pointeurs et protègent contre les problèmes liés à la gestion bas niveau de la mémoire, tels que l'accès à une zone mémoire après sa libération, la déréférence de pointeurs nuls, le dépassement de tampon, etc. Pour faciliter la diffusion des bibliothèques, assurer la compilation et gérer les dépendances, un gestionnaire de paquets nommé Cargo est en développement. Un dépôt pour le déploiement des bibliothèques, crates.io, est également supporté.
La sécurité de la mémoire dans Rust est assurée au moment de la compilation grâce à la vérification des références, au suivi de la propriété des objets, à la prise en compte de la durée de vie des objets (portée) et à l'évaluation de l'accès mémoire pendant l'exécution du code. Rust offre également des outils pour se protéger contre les débordements d'entiers, exige l'initialisation obligatoire des valeurs des variables avant leur utilisation, gère mieux les erreurs dans la bibliothèque standard, applique le concept d'immuabilité (immutable) pour les références et les variables par défaut, et propose une forte typage statique pour minimiser les erreurs logiques.
Les principales nouveautés :
- Une nouvelle commande « info » a été ajoutée au gestionnaire de paquets cargo pour afficher des informations sur les paquets dans le dépôt.
- La prise en charge de la syntaxe « use » dans « impl Trait » a été ajoutée, définissant des informations sur les types cachés. Par exemple, « impl Trait + use » indique que seuls les paramètres « x » et « T » sont autorisés dans le type caché.
- Une syntaxe distincte pour la création de pointeurs bruts a été proposée, remplaçant les macros utilisées auparavant : le macro « addr_of!(expr) » est remplacé par l'opérateur « &raw const expr », et le macro « addr_of_mut!(expr) » par l'opérateur « &raw mut expr ». struct Packed { not_aligned_field: i32, } fn main() { let p = Packed { not_aligned_field: 1_82 }; // Ancienne méthode pour créer un pointeur brut let ptr = std::ptr::addr_of!(p.not_aligned_field); // Nouvelle méthode pour créer un pointeur brut let ptr = &raw const p.not_aligned_field; let val = unsafe { ptr.read_unaligned() }; }
- Il est désormais possible de définir des fonctions et constantes sûres (safe) avec une durée de vie 'static' à l'intérieur de blocs extern marqués comme « unsafe » (auparavant, tous les éléments dans « unsafe extern » devaient être marqués « unsafe ») : unsafe extern { pub safe static TAU: f64; pub safe fn sqrt(x: f64) -> f64; pub unsafe fn strlen(p: *const u8) -> usize; }
- Les attributs no_mangle, link_section et export_name, qui peuvent entraîner un comportement indéterminé, sont désormais considérés comme non sûrs et nécessitent une indication explicite « unsafe », par exemple : #[unsafe(no_mangle)] pub fn my_global_function() { }
- Lors de l'appariement de modèles, il est permis de passer des types vides, tels que « enum Void {} » ou des structures avec un champ vide visible. use std::convert::Infallible; pub fn unwrap_without_panic(x: Result) -> T { let Ok(x) = x; // « Err » peut être ignoré x }
- Le comportement des types à virgule flottante (f32 et f64) a été standardisé lors du traitement des valeurs non numériques NaN (0.0/0.0), et l'utilisation d'opérations à virgule flottante dans les const fn est désormais autorisée.
- Les insertions assembleur offrent la possibilité d'utiliser des opérandes avec le qualificatif «const» pour utiliser directement des valeurs entières sans les sauvegarder préalablement dans un registre. const MSG: &str = «Hello, world!\n»; unsafe { core::arch::asm!( «mov rdx, {LEN} // l'instruction 'mov rdx, 14' sera générée», LEN = const MSG.len(), … ); }
- L'adressage des expressions avec le qualificatif «static» est autorisé dans un contexte sécurisé sans définir de bloc unsafe (les opérateurs «&raw mut» et «&raw const» n'influent pas sur la valeur de l'opérande et créent uniquement un pointeur vers celui-ci): static mut STATIC_MUT: Type = Type::new(); extern «C» { static EXTERN_STATIC: Type; } fn main() { let static_mut_ptr = &raw mut STATIC_MUT; let extern_static_ptr = &raw const EXTERN_STATIC; }
- Une nouvelle série d'API a été stabilisée dans la catégorie des API stables, notamment des méthodes et des implémentations de traits stabilisées :
- std::thread::Builder::spawn_unchecked
- std::str::CharIndices::offset
- std::option::Option::is_none_or
- [T]::is_sorted
- [T]::is_sorted_by
- [T]::is_sorted_by_key
- Iterator::is_sorted
- Iterator::is_sorted_by
- Iterator::is_sorted_by_key
- std::future::Ready::into_inner
- std::iter::repeat_n
- impl DoubleEndedIterator for Take
Source : opennet.ru
