बाइनरी मानों की स्ट्रिंग को चार

Question

उदाहरण

नोट: कि मैं केवल अक्षरों के बारे में चिंतित हूं। इसलिए बिटसेट 000001 a या A होगा।

मेरे पास string नाम "abc" के साथ s है। मैं string के प्रत्येक char लेता हूं और इसे bitset के उपयोग से बाइनरी मान में परिवर्तित करता हूं।

, उदा,

bitset <6> b1 = s[0]; //a 
bitset <6> b2 = s[1]; //b 
bitset <6> b3 = s[2]; //c 

तो मैं strings के array में परिणाम रखना चाहते हैं। सरणी के नाम arr है (और array से प्रत्येक string प्रत्येक char की बाइनरी मूल्य का प्रतिनिधित्व करेंगे)

जैसे

arr[0] //will hold the value of char 'a' in binary form which is 000001 
arr[1] //will hold the value of char 'b' in binary form which is 000010 
arr[2] //will hold the value of char 'c' in binary form which is 000011 

और जिस तरह मैं बाइनरी string से प्रत्येक char परिवर्तित

है

arr[0] = b1.to_string(); //arr[0] is now 000001 
arr[1] = b2.to_string(); //arr[1] is now 000010 
arr[2] = b3.to_string(); //arr[2] is now 000011 

अब मेरी समस्या है। मैं उन्हें वापस char में कैसे परिवर्तित करूं?

उदा।

//I want each char to take back the each corresponding letter from the binary values 

char c1; //How do i make the arr[0] value of 000001 to become 'a' again? 
char c2; //Same here 
char c3; //And here 

Answer 1

मान लिया जाये कि आप ASCII कोड 64 पर शुरू करना चाहते हैं, और कहा कि 'a' (या 'A') बस उस मामले में 000001 है, तो आप बस

c1 = static_cast<char>(std::bitset<6>(arr[0]).to_ulong() + 64); // 

दशमलव में 'A'65 है में कर सकते हैं, बाइनरी 0b01000001 है। दशमलव में 'a' है 97, बाइनरी में 0b01100001 है। अपने कोड में, आप 'a' (या 'A') स्टोर करने के लिए bitset<6> का उपयोग करते हैं। bitset<6> केवल 2^6 प्रतीकों का प्रतिनिधित्व कर सकता है, यानी 64, तो आप काटने का सामना करेंगे। असल में 2 सबसे महत्वपूर्ण बिट्स काट दिया जाएगा। इस मामले में, bitset<6>('A')0b000001, यानी 1 दशमलव में, और bitset<6>('a')0b1000001, यानी 33 दशमलव में बन जाता है। अब आप स्वयं को यह समझ सकते हैं कि 64 वापस जोड़ना सही परिणाम उत्पन्न करता है।

संपादित

ध्यान दें कि आप भी std::stoi (सी ++ 11 केवल) के रूप में अन्य उत्तर में वर्णित का उपयोग करने के लिए दशमलव आधार 2 से बिट श्रृंखला कन्वर्ट करने के लिए कर सकते हैं,:

char c1 = static_cast<char>(std::stoi(arr[0], nullptr, 2) + 64); 

Answer 2

उत्पादन

साथ

std::cout << "abc" << std::endl; 

std::cout << 'a' << 'b' << 'c' << std::endl; 

std::cout << std::dec 
      << static_cast<int>('a') << " " 
      << static_cast<int>('b') << " " 
      << static_cast<int>('c') << " "<< std::endl; 

std::cout << std::hex 
      << static_cast<int>('a') << " " 
      << static_cast<int>('b') << " " 
      << static_cast<int>('c') << " "<< std::endl; 

: निम्नलिखित पर विचार

एबीसी

एबीसी

यह दिखाता है कि प्रत्येक चार बाइनरी है, और 97 दिसम्बर 0x61 हेक्स है।

रूपांतरण (बिट्स के माध्यम से बाइनरी से /) आवश्यक नहीं है।

(या शायद मुझे समझ में नहीं आता कि आप कुछ जटिल फैशन में क्यों नहीं करना चाहते हैं)।

ध्यान दें कि static_cast <> कोई कोड जेन नहीं होता है। ध्यान दें कि std :: dec और std :: हेक्स डेटा में कोई बदलाव नहीं करता है, बस रेडिक्स पर।

संपादित करें --- केवल 8 बिट्स के लिए, आप इस पर विचार कर सकते हैं ... कोई एंडियन समस्या नहीं है।

std::cout << ((('a' >> 7) & 1) ? '1' : '0') 
      << ((('a' >> 6) & 1) ? '1' : '0') 
      << ((('a' >> 5) & 1) ? '1' : '0') 
      << ((('a' >> 4) & 1) ? '1' : '0') 
      << ((('a' >> 3) & 1) ? '1' : '0') 
      << ((('a' >> 2) & 1) ? '1' : '0') 
      << ((('a' >> 1) & 1) ? '1' : '0') 
      << ((('a' >> 0) & 1) ? '1' : '0') << " " 
      << ((('b' >> 7) & 1) ? '1' : '0') 
      << ((('b' >> 6) & 1) ? '1' : '0') 
      << ((('b' >> 5) & 1) ? '1' : '0') 
      << ((('b' >> 4) & 1) ? '1' : '0') 
      << ((('b' >> 3) & 1) ? '1' : '0') 
      << ((('b' >> 2) & 1) ? '1' : '0') 
      << ((('b' >> 1) & 1) ? '1' : '0') 
      << ((('b' >> 0) & 1) ? '1' : '0') << " " 
      << ((('c' >> 7) & 1) ? '1' : '0') 
      << ((('c' >> 6) & 1) ? '1' : '0') 
      << ((('c' >> 5) & 1) ? '1' : '0') 
      << ((('c' >> 4) & 1) ? '1' : '0') 
      << ((('c' >> 3) & 1) ? '1' : '0') 
      << ((('c' >> 2) & 1) ? '1' : '0') 
      << ((('c' >> 1) & 1) ? '1' : '0') 
      << ((('c' >> 0) & 1) ? '1' : '0') << " " 
      << std::endl; 


std::cout << std::dec << std::endl; 


// with variable 
char zulu = 'A'; 

std::cout << std::dec 
      << "NOTE: in this cout, every use of zulu is a 'read' \n" 
      << " zulu: " << zulu        << " \n" 

      << " dec : " << std::dec << static_cast<int>(zulu) << " \n" 
      << " --- : " << zulu        << " \n" // zulu not changed 

      << " hex : " << std::hex << static_cast<int>(zulu) << " \n" 
      << " --- : " << zulu        << " \n" // zulu not changed 

      << " bin : " 
      << (((zulu >> 7) & 1) ? '1' : '0') 
      << (((zulu >> 6) & 1) ? '1' : '0') 
      << (((zulu >> 5) & 1) ? '1' : '0') 
      << (((zulu >> 4) & 1) ? '1' : '0') 
      << (((zulu >> 3) & 1) ? '1' : '0') 
      << (((zulu >> 2) & 1) ? '1' : '0') 
      << (((zulu >> 1) & 1) ? '1' : '0') 
      << (((zulu >> 0) & 1) ? '1' : '0') << " \n" 
      << " --- : " << zulu        << " \n" // zulu not changed 

      << " bitset: " << std::bitset<8>(zulu)    << " \n" 
      << " zulu: " << zulu        << " \n\nzulu not changed!" // zulu not changed 

      << std::endl; 

Answer 3

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

static_cast<char>(std::stoi(arr[i],0,2) + 64); 

एक आधार 2 (बाइनरी) संख्या के रूप में मूल द्विआधारी प्रतिनिधित्व व्याख्या करती है और 64 कहते हैं जब से तुम arr सरणी में एक द्विआधारी प्रारूप में संग्रहीत मूल char रों है, तो आप std::stoi करने के लिए उन्हें गुजरती हैं और है कि निर्दिष्ट कर सकते हैं मान 3 पैरामीटर में बेस 2 हैं। std::stoi को 3 पैरामीटर की आवश्यकता होती है: जिस स्ट्रिंग को आप कनवर्ट करने का प्रयास कर रहे हैं, एक इंटरेक्ट के लिए एक पॉइंटर जो पहले अनवरोधित वर्ण की अनुक्रमणिका को स्टोर करेगा (यहां अनदेखा किया गया है, इसलिए 0 के रूप में छोड़ा जा सकता है), और स्ट्रिंग तर्क का आधार। Here's more info on that। std::stoi कॉल का परिणाम बाइनरी मानों के आधार 10 (दशमलव) के बराबर है। बनामॉफ्टको का जवाब बताता है कि क्यों 64 जोड़ना दशमलव प्रतिनिधित्व प्राप्त करने के बाद यहां करने के लिए उचित संचालन है। इसका परिणाम char के रूप में वापस दिया गया है।

आप एक बड़ा std::bitset तुम भी स्क्रैप जोड़ने 64

यहाँ एक लाइव डेमो है सकते हैं का उपयोग करने के लिए खर्च कर सकते हैं:

Demo