परिचय

डेटा प्रोग्रामिंग की व्यापक विचारधारा के बावजूद, रस्ट प्रोग्रामिंग भाषा में भी असुरक्षित प्रोग्रामिंग विधियां हैं, क्योंकि कभी-कभी वे अनावश्यक गणनाओं को समाप्त करके गति बढ़ा सकते हैं, और कभी-कभी यह केवल एक महत्वपूर्ण आवश्यकता है।

उनमें से एक हमारी वर्तमान मिसाल है - आंतरिक mem::transmute<T, U> , इन दोनों के लिए डिज़ाइन किया गया है, जो बहुत ही असामान्य स्थितियों में काम में आते हैं।

कार्यात्मक विवरण

mem::transmute<T, U> कंपाइलर द्वारा सीधे लागू किया जाता है, क्योंकि परिभाषा के अनुसार इसे रूस्ट भाषा के सिंटैक्स द्वारा वर्णित नहीं किया जा सकता है। यह बस एक डेटा प्रकार के बिट्स को दूसरे के बिट्स के रूप में पुन: व्याख्या करता है:

 pub unsafe extern "rust-intrinsic" fn transmute<T, U>(e: T) -> U 

पुन: व्याख्या करने से पहले, यह फ़ंक्शन डेटा प्रकार T के पुनर्व्याख्या वाले चर के स्वामित्व को लेता है, और उसके बाद इसे "भूल जाता है" (लेकिन संबंधित विध्वंसक को बुलाए बिना)।

भौतिक स्मृति में कोई भी नकल नहीं होती है, क्योंकि यह आंतरिक सिर्फ संकलक को स्पष्ट करता है कि टाइप T की सामग्री वास्तव में, प्रकार U

यदि T और U लंबाई अलग-अलग है, तो संकलन त्रुटि होगी। न तो तर्क और न ही रिटर्न मान अमान्य मान हो सकते हैं ।

अपरिभाषित व्यवहार

जैसा कि आपने देखा होगा, यह फ़ंक्शन असुरक्षित के रूप में चिह्नित है, जो तार्किक है, क्योंकि यह कई कारकों के कारण अपरिभाषित व्यवहार उत्पन्न कर सकता है:

• अमान्य स्थिति के साथ किसी भी प्रकार का उदाहरण बनाना;
• अमान्य मान के साथ एक आदिम बनाना;
• प्रकार के अनुमान को संतुष्ट करने के लिए, यदि यह निर्दिष्ट नहीं है, तो पूरी तरह से अप्रत्याशित आउटपुट प्रकार संभव है;
• non-repr(C) प्रकारों के बीच बातचीत;
• एक स्पष्ट रूप से निर्दिष्ट जीवन समय के बिना नियमित लिंक से संबंधित असंबंधित जीवन समय में परिणाम;
• एक अपरिवर्तनीय लिंक को एक उत्परिवर्ती एक में बदलना।

खुले अवसर

हालांकि, यह तकनीक कुछ विशेष मामलों में खुद को सही ठहराती है, उदाहरण के लिए, एक फ्लोटिंग-पॉइंट डेटा प्रकार का एक सा पैटर्न प्राप्त करना (या, आमतौर पर, टाइपिंग पाइंटिंग, जहां T और U कच्चे पॉइंटर्स नहीं हैं):

 let bitpattern = unsafe { std::mem::transmute::<f32, u32>(1.0) }; assert_eq!(bitpattern, 0x3F800000); 

एक रॉ पॉइंटर को पॉइंटर से एक फंक्शन में कन्वर्ट करें। यह ध्यान देने योग्य है कि यह तकनीक उन प्लेटफार्मों के बीच पोर्टेबल नहीं है जहां फ़ंक्शन पॉइंटर्स और नियमित पॉइंटर्स आकार में भिन्न होते हैं।

 fn foo() -> i32 { 0 } let pointer = foo as *const (); let function = unsafe { std::mem::transmute::<*const (), fn() -> i32>(pointer) }; assert_eq!(function(), 0); 

जीवन समय विस्तार या अपरिवर्तनीय जीवन समय को छोटा करना। यह एक बहुत ही असुरक्षित और एक ही समय में उन्नत जंग सिंटैक्स है:

 struct R<'a>(&'a i32); unsafe fn extend_lifetime<'b>(r: R<'b>) -> R<'static> { std::mem::transmute::<R<'b>, R<'static>>(r) } unsafe fn shorten_invariant_lifetime<'b, 'c>(r: &'b mut R<'static>) -> &'b mut R<'c> { std::mem::transmute::<&'b mut R<'static>, &'b mut R<'c>>(r) } 

विकल्प बख्शा

मूल रूप से, as सहजता से mem::transmute<T, U> कारण अपरिभाषित व्यवहार को रोक सकता है mem::transmute<T, U> :

 let ptr = &mut 0; let val_transmuted = unsafe { std::mem::transmute::<&mut i32, &mut u32>(ptr) }; //   `as`  .  ,  //   `as    let val_casts = unsafe { &mut *(ptr as *mut i32 as *mut u32) }; 

और सुरक्षित तरीकों का भी उपयोग किया जा सकता है, mem::transmute<T, U> को एक समान कॉल के रूप में एक ही काम कर रहा है mem::transmute<T, U> :

 //        //    let slice = unsafe { std::mem::transmute::<&str, &[u8]>("Rust") }; assert_eq!(slice, &[82, 117, 115, 116]); //      `as_bytes()`,  //     let slice = "Rust".as_bytes(); assert_eq!(slice, &[82, 117, 115, 116]); //      //   assert_eq!(b"Rust", &[82, 117, 115, 116]); 

और इस स्रोत कोड को slice::split_at_mut() तीन कार्यान्वयनों द्वारा प्रदर्शित किया जाता है slice::split_at_mut() फ़ंक्शन: mem::transmute<T, U> का उपयोग करना mem::transmute<T, U> , ऑपरेटर और slice::from_raw_parts() फ़ंक्शन।

 use std::{slice, mem}; //     ,    //     fn split_at_mut_transmute<T>(slice: &mut [T], mid: usize) -> (&mut [T], &mut [T]) { let len = slice.len(); assert!(mid <= len); unsafe { let slice2 = mem::transmute::<&mut [T], &mut [T]>(slice); // -, mem::transmute<T, U>   , //  ,    -    T  U. // // -,      ,  //        (&mut slice[0..mid], &mut slice2[mid..len]) } } //       ; `&mut *` //    `&mut T`  `&mut T`  `*mut T`. fn split_at_mut_casts<T>(slice: &mut [T], mid: usize) -> (&mut [T], &mut [T]) { let len = slice.len(); assert!(mid <= len); unsafe { let slice2 = &mut *(slice as *mut [T]); //        ,  //        (&mut slice[0..mid], &mut slice2[mid..len]) } } //    ,    //  fn split_at_stdlib<T>(slice: &mut [T], mid: usize) -> (&mut [T], &mut [T]) { let len = slice.len(); assert!(mid <= len); unsafe { let ptr = slice.as_mut_ptr(); //      ,  //    : `slice`, r-value ret.0  r-value ret.1. // // `slice`     `let ptr = ...`,   // ,    "",  ,  //      . (slice::from_raw_parts_mut(ptr, mid), slice::from_raw_parts_mut(ptr.add(mid), len - mid)) } } 

दूसरे शब्दों में, mem::transmute<T, U> का उपयोग mem::transmute<T, U> केवल तब ही उचित है जब कुछ और मदद नहीं करता (कुछ भाषाओं में प्रतिबिंब के साथ सादृश्य यहाँ उपयुक्त है)।

भिन्नता मेम :: ट्रांसमिट_कोपी <टी, यू>

सामान्य आंतरिक mem::transmute<T, U> उन मामलों में उपयुक्त नहीं हो सकता है जहां टाइप T के एक चर के स्वामित्व को स्थानांतरित करना असंभव है। इसकी विविधता mem::transmute_copy<T, U> बचाव के लिए आता है:

 pub unsafe fn transmute_copy<T, U>(src: &T) -> U 

जैसा कि आपने अनुमान लगाया है, एक तर्क को आगे बढ़ाने के बजाय, यह इसकी पूरी प्रतिलिपि बनाता है और परिणाम के स्वामित्व को स्थानांतरित करता है। यह भिन्नता अधिक धीमी गति से काम करेगी, इसलिए इसे कम बार उपयोग करने की सिफारिश की जाती है।

mem::transmute<T, U> विपरीत mem::transmute<T, U> , वर्तमान एनालॉग एक संकलक त्रुटि उत्पन्न नहीं करता है यदि प्रकार T और U बाइट्स में अलग-अलग लंबाई है, लेकिन यह दृढ़ता से केवल तभी कॉल करने की सिफारिश की जाती है जब उनका आकार समान हो।

यह भी याद रखने योग्य है कि यदि U एक आकार T आकार से अधिक है, तो यह फ़ंक्शन अपरिभाषित व्यवहार उत्पन्न करता है।

निष्कर्ष

एक बार फिर, मैं ध्यान देता हूं कि विचाराधीन कार्यों का उपयोग केवल उन मामलों में किया जाना चाहिए, जब आप उनके बिना नहीं कर सकते। जैसा कि नोमिकोन कहते हैं, यह वास्तव में सबसे असुरक्षित चीज है जिसे आप रस्ट में कर सकते हैं।

इस लेख के सभी उदाहरण mem::transmute<T, U> , और यहां और यहां से सामग्री का भी उपयोग किया गया था। मुझे उम्मीद है कि लेख आपके लिए उपयोगी था।