मैं एक साइन-अवगत हेक्साडेसिमल प्रतिनिधित्व करने के लिए एक हस्ताक्षरित पूर्णांक स्वरूपण कैसे करूँ?

Question

मेरे प्रारंभिक आशय एक तरीका है कि संख्या के साइन को बरकरार रखता है में अपनी षोडश आधारी प्रतिनिधित्व करने के लिए एक हस्ताक्षरित आदिम संख्या परिवर्तित करने के लिए किया गया था। ऐसा लगता है कि हस्ताक्षर किए आदिम पूर्णांकों के लिए LowerHex, UpperHex और रिश्तेदारों की वर्तमान कार्यान्वयन बस अहस्ताक्षरित के रूप में उन्हें इलाज होगा। क्या अतिरिक्त स्वरूपण झंडे मैं जोड़ने कि चाहे जो भी हो, इन कार्यान्वयन बस प्रयोजनों के स्वरूपण के लिए अपने अहस्ताक्षरित समकक्ष के रूप में संख्या पुनर्व्याख्या दिखाई देते हैं। (Playground)

println!("{:X}", 15i32);   // F 
println!("{:X}", -15i32);   // FFFFFFF1 (expected "-F") 
println!("{:X}", -0x80000000i32); // 80000000 (expected "-80000000") 
println!("{:+X}", -0x80000000i32); // +80000000 
println!("{:+o}", -0x8000i16);  // +100000 
println!("{:+b}", -0x8000i16);  // +1000000000000000 

std::fmt में प्रलेखन ऐसा माना जाता है, इस पर स्पष्ट नहीं है, या यहाँ तक कि वैध है, और UpperHex (या किसी अन्य स्वरूपण विशेषता) पर हस्ताक्षर किए पूर्णांक के लिए कार्यान्वयन की व्याख्या का उल्लेख नहीं करता हस्ताक्षर के रूप में संख्याएं। जंग के गिटहब भंडार पर कोई संबंधित समस्या नहीं है।

अंत में, एक विशेष कार्य कार्य (नीचे के रूप में) के लिए, फ़ॉर्मेटर एपीआई के साथ बहुत संगत नहीं किया जा रहा है की दुर्भाग्यपूर्ण नकारात्मक पक्ष के साथ लागू कर सकते हैं।

fn to_signed_hex(n: i32) -> String { 
    if n < 0 { 
     format!("-{:X}", -n) 
    } else { 
     format!("{:X}", n) 
    } 
} 

assert_eq!(to_signed_hex(-15i32), "-F".to_string()); 

क्या यह व्यवहार हस्ताक्षरित पूर्णांक प्रकारों के लिए जानबूझकर है? क्या मानक स्वरूप Formatter का पालन करते समय इस स्वरूपण प्रक्रिया को करने का कोई तरीका है?

Answer 1

क्या इस प्रारूपण प्रक्रिया को करने का कोई तरीका है जबकि अभी भी मानक Formatter का पालन करना है?

हां, लेकिन आपको UpperHex का एक अलग कार्यान्वयन प्रदान करने के लिए एक नया प्रकार बनाने की आवश्यकता है। यहाँ एक कार्यान्वयन कि +, # और 0 झंडे का सम्मान करता है (और शायद अधिक, मैं परीक्षण नहीं किया) है:

use std::fmt::{self, Formatter, UpperHex}; 

struct ReallySigned(i32); 

impl UpperHex for ReallySigned { 
    fn fmt(&self, f: &mut Formatter) -> fmt::Result { 
     let prefix = if f.alternate() { "0x" } else { "" }; 
     let bare_hex = format!("{:X}", self.0.abs()); 
     f.pad_integral(self.0 >= 0, prefix, &bare_hex) 
    } 
} 

fn main() { 
    for &v in &[15, -15] { 
     for &v in &[&v as &UpperHex, &ReallySigned(v) as &UpperHex] { 
      println!("Value: {:X}", v); 
      println!("Value: {:08X}", v); 
      println!("Value: {:+08X}", v); 
      println!("Value: {:#08X}", v); 
      println!("Value: {:+#08X}", v); 
      println!(); 
     } 
    } 
}