चार के

Question

के बिटवाइफ्ट स्थानांतरण सरणी में मुझे वर्णों की एक सरणी मिली है कि मैं >>, & को अन्य सरणी के साथ थोड़ा सा शिफ्ट करने की कोशिश कर रहा हूं। मुझे लगता है कि मुझे यह कैसे करना है इसका गलत विचार है।

मैंने सोचा, भले ही यह था बस my_array >>= 1 बताते हुए वर्ण की एक सरणी सब कुछ बदलाव होगा, लेकिन मैं एक त्रुटि हो रही है: "error: invalid operands to binary >> (have ‘char[8]’ and ‘int’)"

बिटवाइज़ तुलना मैं करता हूँ कोशिश कर रहा हूँ एक समान आकार सरणी सभी के लिए शुरू के साथ है "0 का" ... इसके लिए मुझे मिल रहा है: "error: invalid operands to binary & (have ‘char *’ and ‘char *’)"

क्या मुझे बदलाव और तुलना करने से पहले इन सरणी को किसी अन्य चीज़ में बदलने की ज़रूरत है?

क्षमा करें, मैं बहुत स्पष्ट नहीं था ... इस बिंदु तक सभी महान सलाह और मुझे लगता है कि मैं और अधिक महसूस कर रहा हूं कि ऐसा करने का कोई आसान तरीका नहीं है। अधिक विशेष रूप से, जो मैं करने की कोशिश कर रहा हूं वह WHOLE चार सरणी दाएं 1 के बिट्स को स्थानांतरित कर रहा है, बिट को सरणी के बाईं तरफ बाईं ओर दाएं स्थानांतरित कर दिया गया है, बिटटाइव को उसी आकार की दूसरी सरणी से तुलना करें।

तकनीकी रूप से तुलना सरणी के साथ सरणी नहीं है ... मुझे बस बिट्स की आवश्यकता है। शिफ्ट/तुलना करने की कोशिश करने से पहले सरणी को किसी और चीज में परिवर्तित करना आसान होगा?

Answer 1

आप बदलाव और elementwise तुलना करने के लिए किया है।

for(i = 0; i < len; ++i) 
    array[i] >>= 3; 

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

unsigned char bits1 = 0, bits2 = 0; 
for(i = len-1; i >= 0; --i) { 
    bits2 = array[i] & 0x07; 
    array[i] >>= 3; 
    array[i] |= bits1 << 5; 
    bits1 = bits2; 
} 

दूसरी दिशा में सरणी traversing क्योंकि आप अगले से बिट्स की जरूरत है उच्च स्लॉट

Answer 2

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

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

यदि आप उस शिफ्ट-इन-द-अगली-बाइट व्यवहार को चाहते हैं, और अपने कोड को गंदा और गैर-पोर्टेबल और बग-प्रोन बनाने में कोई फर्क नहीं पड़ता है, तो आप सरणी में पॉइंटर ले सकते हैं, इसे कास्ट कर सकते हैं unsigned long long * जैसे कुछ करने के लिए, इसे कम करें और परिणामी पूर्णांक को स्थानांतरित करें, और इसे दोबारा स्टोर करें।

लेकिन अगर यह व्यवहार आप चाहते हैं तो आपको char[8] के बजाय शुरू करने के लिए एक पूर्णांक का उपयोग करना चाहिए।

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

Answer 3

यदि आप सरणी/OR/XOR/AND/आदि जैसे संचालन करना चाहते हैं तो सरणी पर, आपको इसे लूप में करना चाहिए, आप इसे सीधे सरणी पर निष्पादित नहीं कर सकते हैं।

Answer 4

आप केवल उस सरणी, एक char (या int) के सदस्यों को स्थानांतरित कर सकते हैं। आप एक संपूर्ण सरणी नहीं बदल सकते हैं। स्थानांतरण my_array एक सरणी प्रकार (या चार के लिए एक सूचक) पर एक शिफ्ट ऑपरेशन करने की कोशिश करता है जो असंभव है।बजाय इस है:

for (i = 0; i < size; i++) { 
    my_array[i] >>= 1; 
} 

इसके अलावा, आप वर्ण के साथ सावधान रहना चाहिए क्योंकि वे आम तौर पर हस्ताक्षर किए हैं, और एक चार एक नकारात्मक मूल्य युक्त शून्य के बजाय बाएं से लाना होगा '1'। तो आप बेहतर हस्ताक्षर किए गए वर्णों का उपयोग करते हैं।

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

Answer 5

/** Shift an array right. 
* @param ar The array to shift. 
* @param size The number of array elements. 
* @param shift The number of bits to shift. 
*/ 
void shift_right(unsigned char *ar, int size, int shift) 
{ 
    int carry = 0;        // Clear the initial carry bit. 
    while (shift--) {       // For each bit to shift ... 
     for (int i = size - 1; i >= 0; --i) { // For each element of the array from high to low ... 
      int next = (ar[i] & 1) ? 0x80 : 0; // ... if the low bit is set, set the carry bit. 
      ar[i] = carry | (ar[i] >> 1);  // Shift the element one bit left and addthe old carry. 
      carry = next;      // Remember the old carry for next time. 
     } 
    } 
}