La sortie du langage de programmation polyvalent Rust 1.82, fondé par le projet Mozilla, mais maintenant développé sous les auspices de l'organisation indépendante à but non lucratif Rust Foundation, a été publiée. Le langage se concentre sur la sécurité de la mémoire et fournit les moyens d'atteindre un parallélisme élevé des tâches tout en évitant l'utilisation d'un ramasse-miettes et d'un temps d'exécution (le temps d'exécution est réduit à l'initialisation et à la maintenance de base de la bibliothèque standard).
Les méthodes de gestion de la mémoire de Rust évitent au développeur les erreurs lors de la manipulation des pointeurs et protègent contre les problèmes qui surviennent en raison de la gestion de la mémoire de bas niveau, comme l'accès à une zone mémoire après qu'elle a été libérée, le déréférencement des pointeurs nuls, les dépassements de mémoire tampon, etc. Pour distribuer les bibliothèques, fournir des builds et gérer les dépendances, le projet développe le gestionnaire de packages Cargo. Le référentiel crates.io est pris en charge pour l'hébergement de bibliothèques.
La sécurité de la mémoire est fournie dans Rust au moment de la compilation grâce à la vérification des références, au suivi de la propriété des objets, au suivi des durées de vie des objets (portées) et à l'évaluation de l'exactitude de l'accès à la mémoire pendant l'exécution du code. Rust fournit également une protection contre les débordements d'entiers, nécessite une initialisation obligatoire des valeurs de variables avant utilisation, gère mieux les erreurs dans la bibliothèque standard, applique le concept de références et de variables immuables par défaut, propose un typage statique fort pour minimiser les erreurs logiques.
Principales nouveautés :
- La commande « info » a été ajoutée au gestionnaire de paquets cargo pour afficher des informations sur un paquet dans le référentiel.
- Ajout de la prise en charge de la syntaxe "use<..>" dans "impl Trait", qui spécifie des informations sur les types cachés. Par exemple, « impl Trait + use<'x, T> » spécifie que seuls les paramètres « x » et « T » peuvent être utilisés dans un type masqué.
- Une syntaxe distincte pour créer des pointeurs bruts a été proposée, remplaçant les macros précédemment utilisées : la macro « addr_of!(expr) » a été remplacée par l'opérateur « &raw const expr », et la macro « addr_of_mut!(expr) » a été remplacée par l'opérateur "&raw mut" expr". struct Packed { not_aligned_field : i32, } fn main() { let p = Packed { not_aligned_field : 1_82 } ; // Ancienne façon de créer un pointeur brut let ptr = std::ptr::addr_of!(p.not_aligned_field); // Nouvelle façon de créer un pointeur brut let ptr = &raw const p.not_aligned_field; let val = dangereux { ptr.read_unalignementd() }; }
- Il est possible de définir des fonctions et des constantes sûres avec une durée de vie « statique » à l'intérieur des blocs extern avec l'attribut « unsafe » (auparavant, tous les éléments d'un « unsafe extern » ne pouvaient avoir que l'attribut « unsafe ») : unsafe extern { pub safe TAU statique : f64 ; pub sécurisé fn sqrt(x: f64) -> f64; pub dangereux fn strlen(p: *const u8) -> usize; }
- Les attributs no_mangle, link_section et export_name, qui peuvent conduire à un comportement non défini, sont désormais considérés comme dangereux et nécessitent un indicateur "unsafe" explicite, par exemple : #[unsafe(no_mangle)] pub fn my_global_function() { }
- La correspondance de modèles permet d'ignorer les types vides, tels que "enum Void {}" ou les structures avec un champ vide visible. utilisez std::convert::Infaillible ; pub fn unwrap_without_panic (x : Résultat ) -> T { soit Ok(x) = x; // "Err" peut être ignoré x }
- Les types de nombres à virgule flottante (f32 et f64) ont un comportement standardisé lors du traitement de valeurs NaN non numériques (0.0/0.0) et permettent également l'utilisation d'opérations à virgule flottante dans const fn.
- Les inserts d'assemblage offrent la possibilité d'utiliser des opérandes avec l'attribut « const » pour utiliser directement des valeurs numériques entières sans les stocker au préalable dans un registre. const MSG : &str = "Bonjour tout le monde !\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 l'attribut « static » est autorisé dans un contexte sécurisé sans définir de bloc non sécurisé (les opérateurs « &raw mut » et « &raw const » n'affectent pas la valeur de l'opérande et créent uniquement un pointeur vers celui-ci) : static mut STATIC_MUT : Type = Type ::new( ); extern "C" { statique EXTERN_STATIC : Type ; } fn main() { let static_mut_ptr = &raw mut STATIC_MUT; laissez extern_static_ptr = &raw const EXTERN_STATIC; }
- Une nouvelle partie de l'API a été déplacée vers la catégorie stable, dont les méthodes et les implémentations des traits ont été 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
- Itérateur ::is_sorted
- Itérateur ::is_sorted_by
- Itérateur ::is_sorted_by_key
- std :: future :: Ready :: into_inner
- std::iter::repeat_n
- impl DoubleEndedIterator pour prendre
Source: opennet.ru
