परिवर्तित सी ++ जावा

Question

के बिट पैटर्न मैं जावा के लिए एक सी ++ प्रोग्राम परिवर्तित कर रहा हूँ और पूरी तरह से निम्न विधि जो मेरे मन विस्फोट से उड़ा दिया में अटक गई। क्या आप यह समझाने के लिए बहुत दयालु होंगे कि यह विधि क्या कर रही है?

long TSBCA::GetSignedValue(const NDataString &value) 
    { 
     static NDataString s;  
     s = value; 

     long multiplier(1); 
     size_t len(s.Len()); 
     if (len != 0) 
     { 
      if (s[0] >= (char)0xB0 && s[0] <= (char)0xB9) 
      { 
      s[0] &= 0x7F; //Bit Pattern: 0111 1111 
      multiplier = -1; 
      } 
      else if (s[len - 1] >= (char)0xB0 && s[len - 1] <= (char)0xB9) 
      { 
      s[len - 1] &= 0x7F; //Bit Pattern: 0111 1111 
      multiplier = -1; 
      } 
      else 
      multiplier = 1; 
     } 
     else 
      multiplier = 1; 
     return s.ToLong() * multiplier; 
    } 

संपादित करें:

मेरे प्रारंभिक जावा संस्करण:

private long getSignedValue(final String value){ 

     byte[] bytes = value.getBytes(); 
     int length = bytes.length; 
     long multiplier = 1L; 

     if (bytes.length > 0){ 
      if (bytes[0] >= (char)0xB0 && bytes[0] <= (char)0xB9){ 


      bytes[0] &= 0x7F; //Bit Pattern: 0111 1111 
      multiplier = -1; 
      } 
      else if (bytes[length - 1] >= (char)0xB0 && bytes[length - 1] <= (char)0xB9) 
      { 
       bytes[length - 1] &= 0x7F; //Bit Pattern: 0111 1111 
      multiplier = -1; 
      } 
      else 
      multiplier = 1; 
     } 
     else 
      multiplier = 1; 
     return Long.parseLong(Arrays.toString(bytes))* multiplier; 
} 

मैं इसे सही किया?

Answer 1

यह एक बाइट स्ट्रिंग (अर्थात पाठ नहीं) ले जा रहा है और यह करने के लिए एक लंबे परिवर्तित है। यह कई कार्यान्वयन विशिष्ट चीजों पर निर्भर करता है, और टूटा हुआ दिखाई देता है: यह दो अलग-अलग स्थानों से साइन बिट निकालने जा रहा है। एक और मुद्दा अनावश्यक गैर-पुनर्वित्त है (स्थैतिक चर के कारण)।

Answer 2

s[0] &= 0x7F; 

का मतलब बिट और s[0] हेक्स 7F साथ या दूसरे शब्दों में, बाइट मूल्य से संकेत बिट पट्टी। s[len-1] के साथ एक ही है, इसलिए यह:

• एक संख्यात्मक स्ट्रिंग, जहां प्रथम या अंतिम अंकों निशानी सा जोड़ा (0x30 है लेता है - 0x39 == '0' - '9' और 0xB0 - 0xB9 के साथ एक ही सीमा है 0x80 बिट सेट।)
• स्ट्रिप्स कि बिट प्रवेश करते हैं, गुणक
• के रूप में यह याद संकेत
• रिटर्न सेट करने के लिए गुणक का उपयोग कर संख्यात्मक स्ट्रिंग तर्क समझता है कि वह मूल्य

संपादित:

• यह उद्देश्य के अनुसार कार्य नहीं करता है, नए कोड की जाँच करने के लिए कुछ JUnit परीक्षण लिखने के लिए सुनिश्चित हो:

  अपने कोड की समीक्षा मेरा पीछा टिप्पणी करने के लिए सुराग कि वे

• अलग-अलग स्थिरांक में जादू संख्याएं रखें
• byte स्थिरांक का उपयोग करते समय तुलना करें बाइट (मुद्दों पर हस्ताक्षर)
• झूलने और का ब्रेसिज़ मिलना चाहिए और इस मामले में अनावश्यक
• उपयोग new String(byte[]) स्ट्रिंग, नहीं सरणी उपयोगिता वर्ग फिर से संगठित करने के लिए कर रहे हैं।

यह मैं इस संस्करण की ओर जाता है:

// Bit Pattern: 0111 1111 
private static final int BYTE_7F = 0x7F; 

// '0' with sign bit set 
private static final byte BYTE_NEGATIVE_0 = (byte) 0xB0; 

// '9' with sign bit set 
private static final byte BYTE_NEGATIVE_9 = (byte) 0xB9; 


private long getSignedValue(String value) { 

    byte[] bytes = value.getBytes(); 
    final int length = bytes.length; 
    long multiplier = 1; 

    if (0 < length) { 
     if (bytes[0] >= BYTE_NEGATIVE_0 && bytes[0] <= BYTE_NEGATIVE_9) { 

      bytes[0] &= BYTE_7F; 
      multiplier = -1; 

     } else if (bytes[length - 1] >= BYTE_NEGATIVE_0 && bytes[length - 1] <= BYTE_NEGATIVE_9) { 
      bytes[length - 1] &= BYTE_7F; 
      multiplier = -1; 
     } 
    } 

    return Long.parseLong(new String(bytes)) * multiplier; 
} 

तुम अब भी सही टिप्पणियां जोड़ने पर ध्यान देना और अपने प्रलेखन शब्दावली के साथ लाइन में उन्हें लाने के लिए निरंतर नामों को अपडेट करने की है। जैसे कि यह चिह्न (सकारात्मक या नकारात्मक) के कुछ अजीब संस्करण के लिए परीक्षण कर रहा है

Answer 3

लग रहा है।यदि पहला या आखिरी (लेकिन अधिमानतः पहला) वर्ण 0xB0 और 0xB9 के बीच है, तो उसे जो भी चरित्र था (उच्चतम ऑर्डर बिट को 0x30 और 0x39 के बीच बनाना, '0''9' के माध्यम से)। फिर संख्या को नकारात्मक संकेत के साथ वापस करें क्योंकि सामान्य मनुष्य इसे जानते हैं।