उसी आकार के हस्ताक्षरित/हस्ताक्षरित रूपांतरित करने के लिए कोई अनुपालन तरीका

Question

मुझे डर है कि मुझे कुछ मामूली याद आ रही है, लेकिन ऐसा लगता है कि यदि आप मूल हस्ताक्षरित मान को बनाए रखना चाहते हैं तो हस्ताक्षरित प्रकार से/में कनवर्ट करने का कोई वास्तविक सुरक्षित तरीका नहीं है।

reinterpret_cast पर, 5.2.10 पूर्णांक रूपांतरण के लिए एक पूर्णांक सूचीबद्ध नहीं करता है, इस प्रकार यह परिभाषित नहीं किया गया है (और static_cast कोई अतिरिक्त रूपांतरण परिभाषित नहीं करता है)। अभिन्न रूपांतरणों पर 4.7.3 मूल रूप से कहते हैं कि एक बड़े हस्ताक्षरित रूपांतरण को परिभाषित किया जाएगा (इस प्रकार पोर्टेबल नहीं)।

हम जानते हैं कि यह सीमित है, उदाहरण के लिए, uint64_t किसी हार्डवेयर पर, int64_t पर सुरक्षित रूप से परिवर्तनीय होना चाहिए और मूल्य में परिवर्तन किए बिना वापस। इसके अलावा मानक लेआउट प्रकारों के नियम वास्तव में सुरक्षित रूपांतरण की गारंटी देते हैं यदि हम memcpy को असाइन करने के बजाय दो प्रकार के बीच थे।

क्या मैं सही हूँ? क्या कोई वैध कारण है कि कोई अभिन्न प्रकार के आकार के बीच reinterpret_cast क्यों नहीं कर सकता है?

---

स्पष्टीकरण: निश्चित रूप से अहस्ताक्षरित के हस्ताक्षर किए संस्करण एक मूल्य गारंटी नहीं है, लेकिन यह केवल राउंड ट्रिप है कि मैं विचार कर रहा हूँ (अहस्ताक्षरित => हस्ताक्षर किए => अहस्ताक्षरित)

---

अद्यतन: उत्तर पर बारीकी से देखकर और मानक को पार करने के लिए, मुझे विश्वास है कि memcpy वास्तव में काम करने की गारंटी नहीं है, क्योंकि कहीं भी यह नहीं कहता है कि दो प्रकार लेआउट संगत हैं, और न ही चार प्रकार हैं। आगे अद्यतन, सी-मानक में खोदना इस memcpy काम करना चाहिए, क्योंकि लक्ष्य का आकार काफी बड़ा है और यह बाइट्स की प्रतिलिपि बनाता है।

---

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

Answer 1

आप बाहर बिंदु के रूप में, memcpy सुरक्षित है:

uint64_t a = 1ull<<63; 
int64_t b; 
memcpy(&b,&a,sizeof a); 

मूल्य ख अभी भी कार्यान्वयन परिभाषित किया गया है के बाद से सी ++ एक दो के पूरक प्रतिनिधित्व, की आवश्यकता नहीं है, लेकिन यह वापस परिवर्तित आप मूल मूल्य दे देंगे ।

बो पर्सन बताते हैं कि int64_t दो पूरक होगा। इसलिए memcpy के परिणामस्वरूप एक हस्ताक्षरित मान होना चाहिए जिसके लिए हस्ताक्षरित प्रकार पर सरल अभिन्न रूपांतरण वापस मूल हस्ताक्षरित मान के रूप में परिभाषित किया गया है।

uint64_t c = b; 
assert(a == c); 

इसके अलावा, आप अपने खुद के 'signed_cast' रूपांतरण के लिए आसान बनाने के लिए लागू कर सकते हैं (मैं दो के पूरक बात का लाभ लेने नहीं है क्योंकि इन intN_t प्रकार तक सीमित नहीं हैं):

template<typename T> 
typename std::enable_if<std::is_integral<T>::value && std::is_signed<T>::value,T>::type 
signed_cast(typename std::make_unsigned<T>::type v) { 
    T s; 
    std::memcpy(&s,&v,sizeof v); 
    return s; 
} 

template<typename T> 
typename std::enable_if<std::is_integral<T>::value && std::is_unsigned<T>::value,T>::type 
signed_cast(typename std::make_signed<T>::type v) { 
    T s; 
    std::memcpy(&s,&v,sizeof v); 
    return s; 
} 

Answer 2

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

Answer 3

बस चलाने

#include <cstdio> 
#include <stdint.h> 
using namespace std; 

int main() 
{ 
    int64_t a = 5; 
    int64_t aa; 
    uint64_t b; 
    double c; 

    b = *reinterpret_cast<uint64_t *>(&a); 
    aa = *reinterpret_cast<int64_t *>(&b); 

    if (a == aa) { 
     printf("as expected, a == aa\n"); 
    } 

    c = *reinterpret_cast<double *>(&a); 
    aa = *reinterpret_cast<int64_t *>(&c); 

    if (a == aa) { 
     printf("again, as expected, a == aa\n"); 
    } 

    printf("what is this I don't even %f.\n", c); // this one should give some undefined behavior here 

    return 0; 
} 

एक टिप्पणी में फिट नहीं कर सका।

Answer 4

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

को देखते हुए memcpy समाधान मौजूद है कि मुझे लगता है मानक निकाय इस तरह के एक unintuitive मानचित्रण का समर्थन नहीं करने का फैसला किया, शायद इसलिए कि unsigned-> signed-> अहस्ताक्षरित के रूप में pointer-> integer-> सूचक के रूप में उपयोगी एक दृश्य नहीं है।

Answer 5

जब तक मैं सवाल नहीं समझ पाते, सिर्फ एक अहस्ताक्षरित प्रकार में हस्ताक्षर किए प्रकार डाल दिया और इसके विपरीत फिर से वापस जाने के लिए:

#include <iostream> 

int main() 
{ 
    signed char s = -128; 
    unsigned char u = s; 
    signed char back = u; 

    std::cout << (int)u << std::endl; 
    std::cout << (int)back << std::endl; 

    return 0; 
} 

./a.out 
128 
-128 

Answer 6

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

क्या कोई नियम है जो कहता है कि हस्ताक्षरित अभिन्न प्रकारों में जाल प्रतिनिधित्व नहीं हो सकते हैं? (बिना हस्ताक्षर किए गए प्रकार, सीमा निर्धारित करने के तरीके के कारण नहीं हो सकते हैं, वैध मानों के लिए सभी प्रतिनिधित्व की आवश्यकता है)

हस्ताक्षरित प्रस्तुतियों में समकक्ष वर्ग (जैसे +0 == -0) भी शामिल हो सकते हैं और इस तरह के वर्ग में मूल्यों को वाणिज्य में जोड़ सकते हैं कैनोलिक प्रतिनिधित्व, इस प्रकार roundtrip तोड़ने।

यहाँ स्टैंडर्ड से संबंधित नियमों है (4.7, [conv.integral] sectin):

तो गंतव्य प्रकार अहस्ताक्षरित है, जिसके परिणामस्वरूप मूल्य कम से कम अहस्ताक्षरित पूर्णांक स्रोत पूर्णांक के सर्वांगसम है (सापेक्ष 2 ⁿ जहां एन हस्ताक्षरित प्रकार का प्रतिनिधित्व करने के लिए उपयोग की जाने वाली बिट्स की संख्या है)। [नोट: दो के पूरक प्रतिनिधित्व में, यह रूपांतरण वैचारिक है और बिट पैटर्न में कोई बदलाव नहीं है (यदि कोई छंटनी नहीं है)। - अंत नोट]

यदि गंतव्य प्रकार हस्ताक्षरित है, तो मान अपरिवर्तित है यदि इसे गंतव्य प्रकार (और बिट-फील्ड चौड़ाई) में प्रदर्शित किया जा सकता है; अन्यथा, मान कार्यान्वयन-परिभाषित है।

आप एक सूचक या संदर्भ पर reinterpret_cast का उपयोग कर मतलब हैं, बल्कि मूल्य से, आप the strict-aliasing rule से निपटने के लिए। और आपको क्या लगता है कि this case is expressly allowed है।