जवाबों:
सी में, यदि आप बिट हेरफेर छिपाना चाहते हैं, तो आप एक मैक्रो लिख सकते हैं:
#define CHECK_BIT(var,pos) ((var) & (1<<(pos)))और दाहिने छोर से n वें बिट की जांच करने के लिए इसे इस तरह से उपयोग करें :
CHECK_BIT(temp, n - 1)C ++ में, आप std :: bitet का उपयोग कर सकते हैं ।
!= 0सच है, तो परेशान क्यों? 1वास्तव में के रूप में सच है 0.1415!
std::bitsetसचमुच? ज़रूर, एक छोटा सा काम करने के बजाय (और संभावित रूप से कुछ बहुत अच्छे टेम्पलेट) एक बिट की जांच करने के लिए, एक फूला हुआ कंटेनर का उपयोग करें जो अन्यथा अप्रयुक्त में प्रत्येक 'बिट' को संग्रहीत करता है unsigned long। एक स्थान बेकार हो जया!
जांचें कि क्या बिट एन (0 से शुरू) सेट है:
temp & (1 << N)इसके लिए कोई बिल्टइन फंक्शन नहीं है।
1 << 0?? क्षमा करें, भ्रमित।
1<<0, जो कि बिना किसी बदलाव के 1 है (शिफ्ट 0), जो है1<<0 == 1
मैं बस एक std :: बिटसेट का उपयोग करूंगा यदि यह C ++ है। सरल। सीधी-सपाट। बेवकूफ त्रुटियों के लिए कोई मौका नहीं।
typedef std::bitset<sizeof(int)> IntBits;
bool is_set = IntBits(value).test(position);
या इस बेचैनी के बारे में कैसे
template<unsigned int Exp>
struct pow_2 {
static const unsigned int value = 2 * pow_2<Exp-1>::value;
};
template<>
struct pow_2<0> {
static const unsigned int value = 1;
};
template<unsigned int Pos>
bool is_bit_set(unsigned int value)
{
return (value & pow_2<Pos>::value) != 0;
}
bool result = is_bit_set<2>(value);
std::bitset<CHAR_BIT * sizeof(int)>और भी अधिक सही होने के लिए
हाँ, मुझे पता है कि मेरे पास इस तरह से करने के लिए " नहीं " है । लेकिन मैं आमतौर पर लिखता हूं:
/* Return type (8/16/32/64 int size) is specified by argument size. */
template<class TYPE> inline TYPE BIT(const TYPE & x)
{ return TYPE(1) << x; }
template<class TYPE> inline bool IsBitSet(const TYPE & x, const TYPE & y)
{ return 0 != (x & y); }
उदाहरण के लिए:
IsBitSet( foo, BIT(3) | BIT(6) ); // Checks if Bit 3 OR 6 is set.अन्य बातों के अलावा, यह दृष्टिकोण:
चयनित उत्तर जो कर रहा है वह वास्तव में गलत है। नीचे दिए गए फ़ंक्शन बिट स्थिति या 0 पर निर्भर करेगा यदि बिट वास्तव में सक्षम है। यह वह नहीं है जो पोस्टर के लिए पूछ रहा था।
#define CHECK_BIT(var,pos) ((var) & (1<<(pos)))यहाँ वही है जो पोस्टर मूल रूप से देख रहा था। नीचे फ़ंक्शन 1 या 0 पर वापस आ जाएगा यदि बिट सक्षम है और स्थिति नहीं है।
#define CHECK_BIT(var,pos) (((var)>>(pos)) & 1)bool has_feature = CHECK_BIT(register, 25);गुड की तरह इसका उपयोग करते हुए यह जानने के लिए कि मैं इसे डबल-नेगेट के बिना कर सकता हूं।
बिट-फ़ील्ड के इस विवरण के अनुसार , फ़ील्ड को सीधे परिभाषित और एक्सेस करने की एक विधि है। इस प्रविष्टि में उदाहरण जाता है:
struct preferences {
unsigned int likes_ice_cream : 1;
unsigned int plays_golf : 1;
unsigned int watches_tv : 1;
unsigned int reads_books : 1;
};
struct preferences fred;
fred.likes_ice_cream = 1;
fred.plays_golf = 1;
fred.watches_tv = 1;
fred.reads_books = 0;
if (fred.likes_ice_cream == 1)
/* ... */
इसके अलावा, वहाँ एक चेतावनी है:
हालांकि, संरचना में बिट सदस्यों में व्यावहारिक कमियां हैं। सबसे पहले, मेमोरी में बिट्स का क्रम वास्तुकला पर निर्भर है और मेमोरी पैडिंग नियम संकलक से संकलक तक भिन्न होता है। इसके अलावा, कई लोकप्रिय कंपाइलर बिट सदस्यों को पढ़ने और लिखने के लिए अक्षम्य कोड उत्पन्न करते हैं, और इस तथ्य के कारण बिट फ़ील्ड्स (विशेषकर मल्टीप्रोसेसर सिस्टम) से संबंधित संभावित रूप से गंभीर थ्रेड सुरक्षा मुद्दे हैं, जो कि अधिकांश मशीनें मेमोरी में बिट्स के मनमाने सेटों में हेरफेर नहीं कर सकती हैं। लेकिन इसके बजाय पूरे शब्दों को लोड और स्टोर करना होगा।
आप एक बिटसैट - http://www.cppreference.com/wiki/stl/bitset/start का उपयोग कर सकते हैं ।
एसटीडी :: बिटसेट का उपयोग करें
#include <bitset>
#include <iostream>
int main()
{
int temp = 0x5E;
std::bitset<sizeof(int)*CHAR_BITS> bits(temp);
// 0 -> bit 1
// 2 -> bit 3
std::cout << bits[2] << std::endl;
}
tempको "बिग-एंडियन" बनाने के लिए प्रतिबिंबित करने की आवश्यकता नहीं है ?
अर्थात्, _bittest आंतरिक निर्देश है।
मैं इसका उपयोग करता हूं:
#define CHECK_BIT(var,pos) ( (((var) & (pos)) > 0 ) ? (1) : (0) )जहाँ "स्थिति" को 2 ^ n (ig 1,2,4,8,16,32 ...) के रूप में परिभाषित किया गया है
रिटर्न: 1 अगर सच 0 अगर गलत है
4 = 2^(3-1)बिट स्थिति 3 के लिए उपयोग करना चाहिए क्योंकि यह प्रश्न का हिस्सा था।
मैं एक 32-बिट पूर्णांक को पढ़ने की कोशिश कर रहा था, जिसने पीडीएफ में एक ऑब्जेक्ट के लिए झंडे को परिभाषित किया था और यह मेरे लिए काम नहीं कर रहा था
क्या यह परिभाषित बदल रहा था तय:
#define CHECK_BIT(var,pos) ((var & (1 << pos)) == (1 << pos))ऑपरेंड और दोनों में 1 में झंडे के साथ एक पूर्णांक देता है, और यह बूलियन में ठीक से कास्टिंग नहीं कर रहा था, इसने चाल बना दी
!= 0ऐसा ही होगा। पता नहीं कैसे उत्पन्न मशीन निर्देश भिन्न हो सकते हैं।
आप शिफ्टिंग और मास्किंग "अनुकरण" कर सकते हैं: यदि ((0x5e / (2 * 2 * 2))% 2 ...
क्यों नहीं इस के रूप में सरल रूप में कुछ का उपयोग करें?
uint8_t status = 255;
cout << "binary: ";
for (int i=((sizeof(status)*8)-1); i>-1; i--)
{
if ((status & (1 << i)))
{
cout << "1";
}
else
{
cout << "0";
}
}आउट: बाइनरी 11111111
std::cout << (((status & (1 << i)) ? '1' : '0');:। आप का उपयोग करना चाहिए CHAR_BITसे निरंतर <climits>, वैसे भी बजाय कठिन कोडिंग 8 बिट की, हालांकि इस मामले में आप परिणाम पता 8 हो जाएगा के बाद से आप एक प्रयोग कर रहे हैंuint8_t
यदि आप बस एक वास्तविक हार्ड कोडित तरीका चाहते हैं:
#define IS_BIT3_SET(var) ( ((var) & 0x04) == 0x04 )ध्यान दें कि यह hw निर्भर है और इस बिट ऑर्डर को 32६५४ ३२१० मानता है और var and बिट है।
#include "stdafx.h"
#define IS_BIT3_SET(var) ( ((var) & 0x04) == 0x04 )
int _tmain(int argc, _TCHAR* argv[])
{
int temp =0x5E;
printf(" %d \n", IS_BIT3_SET(temp));
temp = 0x00;
printf(" %d \n", IS_BIT3_SET(temp));
temp = 0x04;
printf(" %d \n", IS_BIT3_SET(temp));
temp = 0xfb;
printf(" %d \n", IS_BIT3_SET(temp));
scanf("waitng %d",&temp);
return 0;
}का परिणाम:
१ ० १ १ ०
हालांकि अब जवाब देने में काफी देर हो चुकी है, एक सरल तरीका है जिससे यह पता लगाया जा सकता है कि Nth बिट सेट है या नहीं, बस POWER और MODULUS गणितीय ऑपरेटरों का उपयोग कर रहा है।
हम कहते हैं कि हम जानना चाहते हैं कि 'अस्थायी' में Nth बिट सेट है या नहीं। निम्नलिखित बूलियन अभिव्यक्ति सही है अगर बिट सेट है, 0 अन्यथा।
निम्नलिखित उदाहरण पर विचार करें:
अगर मैं जानना चाहता हूं कि 3rd बिट सेट है या नहीं, मुझे मिलता है
तो अभिव्यक्ति सही है, यह दर्शाता है कि 3 बिट सेट है।
एक दृष्टिकोण निम्नलिखित स्थिति में जाँच करेगा:
if ( (mask >> bit ) & 1)एक स्पष्टीकरण कार्यक्रम होगा:
#include <stdio.h>
unsigned int bitCheck(unsigned int mask, int pin);
int main(void){
unsigned int mask = 6; // 6 = 0110
int pin0 = 0;
int pin1 = 1;
int pin2 = 2;
int pin3 = 3;
unsigned int bit0= bitCheck( mask, pin0);
unsigned int bit1= bitCheck( mask, pin1);
unsigned int bit2= bitCheck( mask, pin2);
unsigned int bit3= bitCheck( mask, pin3);
printf("Mask = %d ==>> 0110\n", mask);
if ( bit0 == 1 ){
printf("Pin %d is Set\n", pin0);
}else{
printf("Pin %d is not Set\n", pin0);
}
if ( bit1 == 1 ){
printf("Pin %d is Set\n", pin1);
}else{
printf("Pin %d is not Set\n", pin1);
}
if ( bit2 == 1 ){
printf("Pin %d is Set\n", pin2);
}else{
printf("Pin %d is not Set\n", pin2);
}
if ( bit3 == 1 ){
printf("Pin %d is Set\n", pin3);
}else{
printf("Pin %d is not Set\n", pin3);
}
}
unsigned int bitCheck(unsigned int mask, int bit){
if ( (mask >> bit ) & 1){
return 1;
}else{
return 0;
}
}आउटपुट:
Mask = 6 ==>> 0110 Pin 0 is not Set Pin 1 is Set Pin 2 is Set Pin 3 is not Set
#define CHECK_BIT(var,pos) ((var>>pos) & 1)स्थिति - 0 से स्ट्रेटिंग वाली बिट स्थिति।
रिटर्न 0 या 1।
मैं इसे बनाता हूं:
LATGbits.LATG0 = ((मीटर और 0x8)> 0); // जाँच करने के लिए कि m का बिट -2 1 है