एक हेक्साडेसिमल स्ट्रिंग को सी में कुशलता से पूर्णांक में कनवर्ट करें?

Question

सी में, हेक्स अंकों की एक स्ट्रिंग को बाइनरी unsigned int या unsigned long में परिवर्तित करने का सबसे प्रभावी तरीका क्या है?

उदाहरण के लिए, यदि मेरे पास 0xFFFFFFFE है, तो मुझे बेस 10 मान 4294967294 के साथ int चाहिए।

Answer 1

आप strtol या strtoul चाहते हैं। देखें भी Unix man page

Answer 2

इस प्रयास करें:

#include <stdio.h> 
int main() 
{ 
    char s[] = "fffffffe"; 
    int x; 
    sscanf(s, "%x", &x); 
    printf("%u\n", x); 
} 

Answer 3

@Eric

क्यों एक कोड समाधान है कि काम करता है के ख़िलाफ़ मतदान हो रहा है? निश्चित रूप से, यह बदसूरत है और ऐसा करने का सबसे तेज़ तरीका नहीं हो सकता है, लेकिन यह अधिक निर्देशक है कि "स्ट्रेटोल" या "एसएसकेएनएफ" कह रहा है। यदि आप इसे स्वयं आज़माते हैं तो आप कुछ सीखेंगे कि चीजें हुड के नीचे कैसे होती हैं।

मुझे सच में नहीं लगता कि आपका समाधान मतदान किया जाना चाहिए था, लेकिन मेरा अनुमान है कि यह क्यों हो रहा है क्योंकि यह कम व्यावहारिक है। मतदान के साथ विचार यह है कि "सर्वश्रेष्ठ" उत्तर शीर्ष पर तैर जाएगा, और जब आपका उत्तर हुड के तहत क्या होता है (या जिस तरह से हो सकता है) के बारे में अधिक निर्देशक हो सकता है, तो यह निश्चित रूप से हेक्स संख्याओं को पार्स करने का सबसे अच्छा तरीका नहीं है एक उत्पादन प्रणाली में।

फिर, मुझे नहीं लगता कि शैक्षणिक दृष्टिकोण से आपके उत्तर में कुछ भी गलत है, और मैं निश्चित रूप से इसे वोट नहीं दूंगा (और नहीं)। निराश न हों और पोस्टिंग रोकें क्योंकि कुछ लोगों को आपके उत्तरों में से कोई एक पसंद नहीं आया। हो जाता है।

मुझे संदेह है कि मेरा जवाब आपको वोट देने के बारे में बेहतर महसूस करता है, लेकिन मुझे पता है कि यह विशेष रूप से मजेदार नहीं है जब आप पूछते हैं कि कुछ क्यों मतदान किया जा रहा है और no one answers।

Answer 4

@Eric

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

ठीक है, मैं कोई सी गुरु हूँ, लेकिन यहाँ क्या मैं के साथ आया है:

unsigned int parseHex(const char * str) 
{ 
    unsigned int val = 0; 
    char c; 

    while(c = *str++) 
    { 
     val <<= 4; 

     if (c >= '0' && c <= '9') 
     { 
      val += c & 0x0F; 
      continue; 
     } 

     c &= 0xDF; 
     if (c >= 'A' && c <= 'F') 
     { 
      val += (c & 0x07) + 9; 
      continue; 
     } 

     errno = EINVAL; 
     return 0; 
    } 

    return val; 
} 

मैं मूल रूप से अधिक bitmasking तुलना के बजाय चल रहा था, लेकिन मैं गंभीरता से संदेह bitmasking किसी भी तुलना में तेजी है आधुनिक हार्डवेयर पर तुलना।

Answer 5

उदाहरण के लिए बड़े हेक्स तारों के लिए मुझे strtoul का उपयोग करने की आवश्यकता है।

Answer 6

एक कोड समाधान क्यों है जो पर काम कर रहा है? बेशक, यह बदसूरत है ...

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

एक सरणी का उपयोग दक्षता के लिए अच्छा हो सकता है, लेकिन इस कोड में इसका उल्लेख नहीं है। इसमें ऊपरी और निचले मामले का कोई खाता नहीं है, इसलिए यह प्रश्न में दिए गए उदाहरण के लिए काम नहीं करता है। एफएफएफएफएफएफई

Answer 7

यदि आपके पास stdlib नहीं है तो आपको इसे मैन्युअल रूप से करना होगा।

unsigned long hex2int(char *a, unsigned int len) 
{ 
    int i; 
    unsigned long val = 0; 

    for(i=0;i<len;i++) 
     if(a[i] <= 57) 
     val += (a[i]-48)*(1<<(4*(len-1-i))); 
     else 
     val += (a[i]-55)*(1<<(4*(len-1-i))); 

    return val; 
} 

नोट: यह कोड अपरकेस ए-एफ मानता है। यह काम नहीं करता है यदि लेन आपके सबसे लंबे पूर्णांक 32 या 64 बिट से परे है, और अवैध हेक्स वर्णों के लिए कोई त्रुटि नहीं है।

Answer 8

यह वर्तमान में केवल निचले मामले के साथ काम करता है लेकिन यह दोनों के साथ काम करने के लिए बहुत आसान है।

cout << "\nEnter a hexadecimal number: "; 
cin >> hexNumber; 
orighex = hexNumber; 

strlength = hexNumber.length(); 

for (i=0;i<strlength;i++) 
{ 
    hexa = hexNumber.substr(i,1); 
    if ((hexa>="0") && (hexa<="9")) 
    { 
     //cout << "This is a numerical value.\n"; 
    } 
    else 
    { 
     //cout << "This is a alpabetical value.\n"; 
     if (hexa=="a"){hexa="10";} 
     else if (hexa=="b"){hexa="11";} 
     else if (hexa=="c"){hexa="12";} 
     else if (hexa=="d"){hexa="13";} 
     else if (hexa=="e"){hexa="14";} 
     else if (hexa=="f"){hexa="15";} 
     else{cout << "INVALID ENTRY! ANSWER WONT BE CORRECT\n";} 
    } 
    //convert from string to integer 

    hx = atoi(hexa.c_str()); 
    finalhex = finalhex + (hx*pow(16.0,strlength-i-1)); 
} 
cout << "The hexadecimal number: " << orighex << " is " << finalhex << " in decimal.\n"; 

Answer 9

के रूप में अगर अक्सर ऐसा होता है, आपके सवाल एक गंभीर पारिभाषिक त्रुटि/अस्पष्टता से ग्रस्त है। आम भाषण में यह आमतौर पर कोई फर्क नहीं पड़ता, लेकिन इस विशिष्ट समस्या के संदर्भ में यह महत्वपूर्ण रूप से महत्वपूर्ण है।

आप देखते हैं, "हेक्स मान" और "दशमलव मान" (या "हेक्स संख्या" और "दशमलव संख्या" जैसी कोई चीज़ नहीं है)। "हेक्स" और "दशमलव" मानों के प्रस्तुतियों गुण हैं। इस बीच, मूल्यों (या संख्याओं) के पास स्वयं का कोई प्रतिनिधित्व नहीं है, इसलिए वे "हेक्स" या "दशमलव" नहीं हो सकते हैं। उदाहरण के लिए, 0xF और 15 सी सिंटैक्स में दो अलग-अलग प्रतिनिधित्वसमान संख्या हैं।

मुझे लगता है कि होगा अपने प्रश्न, जिस तरह से यह कहा गया है, पता चलता है कि यह है कि आप एक मूल्य (एक और स्ट्रिंग) के एक ASCII दशमलव प्रतिनिधित्व में कोई मान (अर्थात एक स्ट्रिंग) की ASCII हेक्स प्रतिनिधित्व बदलना होगा। ऐसा करने का एक तरीका इंटरमीडिएट के रूप में एक पूर्णांक प्रतिनिधित्व का उपयोग करना है: सबसे पहले, एएससीआईआई हेक्स प्रतिनिधित्व को पर्याप्त आकार के पूर्णांक में परिवर्तित करें (strto... समूह से strtol जैसे कार्यों का उपयोग करके), फिर पूर्णांक को ASCII दशमलव प्रतिनिधित्व में परिवर्तित करें sprintf)।

यदि ऐसा नहीं है जो आपको करने की ज़रूरत है, तो आपको अपने प्रश्न को स्पष्ट करना होगा, क्योंकि यह आपके प्रश्न के तरीके से बाहर निकलना असंभव है।

Answer 10

हेक्स दशमलव के

#include<stdio.h> 
    #include<conio.h> 

    int main(void) 
    { 
     int count=0,digit,n,i=0; 
     int hex[5]; 
     clrscr(); 
     printf("enter a number "); 
     scanf("%d",&n); 

     if(n<10) 
     { 
      printf("%d",n); 
     } 

     switch(n) 
     { 
      case 10: 
       printf("A"); 
      break; 
      case 11: 
       printf("B"); 
      break; 
      case 12: 
       printf("B"); 
      break; 
      case 13: 
       printf("C"); 
      break; 
      case 14: 
       printf("D"); 
      break; 
      case 15: 
       printf("E"); 
      break; 
      case 16: 
       printf("F"); 
      break; 
      default:; 
     } 

     while(n>16) 
     { 
      digit=n%16; 
      hex[i]=digit; 
      i++; 
      count++; 
      n=n/16; 
     } 

     hex[i]=n; 

     for(i=count;i>=0;i--) 
     { 
      switch(hex[i]) 
      { 
      case 10: 
       printf("A"); 
       break; 
      case 11: 
       printf("B"); 
       break; 
      case 12: 
       printf("C"); 
       break; 
      case 13: 
       printf("D"); 
       break; 
      case 14: 
       printf("E"); 
       break; 
      case 15: 
       printf("F"); 
       break; 
      default: 
       printf("%d",hex[i]); 
      } 
    } 

    getch(); 

    return 0; 
} 

Answer 11

हेक्साडेसिमल दशमलव से कन्वर्ट करने के लिए इस की कोशिश करो। इसे ऑनलाइन कंपाइलर्स पर न चलाएं, क्योंकि यह काम नहीं करेगा।

#include<stdio.h> 
void main() 
{ 
    unsigned int i; 
    scanf("%x",&i); 
    printf("%d",i); 
} 

Answer 12

संपादित करें: अब MSVC, सी ++ और गैर जीएनयू compilers (अंत देखें) के साथ संगत।

प्रश्न "सबसे प्रभावी तरीका" था। ओपी मंच निर्दिष्ट नहीं करता है, वह अपने कोड के लिए 256 बाइट फ्लैश स्टोरेज के साथ एक आरआईएससी आधारित एटीएमईएल चिप के लिए संकलित कर सकता है।

रिकॉर्ड के लिए, और उन (मेरे जैसे), जो "सबसे आसान तरीका है" और "सबसे कारगर तरीका" के बीच अंतर की सराहना करते हैं, और जो सीखने का आनंद के लिए ...

static const long hextable[] = { 
    [0 ... 255] = -1, // bit aligned access into this table is considerably 
    ['0'] = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, // faster for most modern processors, 
    ['A'] = 10, 11, 12, 13, 14, 15,  // for the space conscious, reduce to 
    ['a'] = 10, 11, 12, 13, 14, 15  // signed char. 
}; 

/** 
* @brief convert a hexidecimal string to a signed long 
* will not produce or process negative numbers except 
* to signal error. 
* 
* @param hex without decoration, case insensitive. 
* 
* @return -1 on error, or result (max (sizeof(long)*8)-1 bits) 
*/ 
long hexdec(unsigned const char *hex) { 
    long ret = 0; 
    while (*hex && ret >= 0) { 
     ret = (ret << 4) | hextable[*hex++]; 
    } 
    return ret; 
} 

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

गैर-जीसीसी या सी ++ कंपाइलर्स या कंपाइलर्स के लिए जो फैंसी हेक्टेबल घोषणा को स्वीकार नहीं करेंगे।

इस के साथ पहले बयान बदलें (लंबे समय तक है, लेकिन अधिक अनुरूप) संस्करण:

static const long hextable[] = { 
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 
    -1,-1, 0,1,2,3,4,5,6,7,8,9,-1,-1,-1,-1,-1,-1,-1,10,11,12,13,14,15,-1, 
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 
    -1,-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 
    -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 
}; 

Answer 13

#include "math.h" 
#include "stdio.h" 
/////////////////////////////////////////////////////////////// 
// The bits arg represents the bit say:8,16,32...                            
///////////////////////////////////////////////////////////// 
volatile long Hex_To_Int(long Hex,char bits) 
{ 
    long Hex_2_Int; 
    char byte; 
    Hex_2_Int=0; 

    for(byte=0;byte<bits;byte++) 
    { 
     if(Hex&(0x0001<<byte)) 
      Hex_2_Int+=1*(pow(2,byte)); 
     else 
      Hex_2_Int+=0*(pow(2,byte)); 
    } 

    return Hex_2_Int; 
} 
/////////////////////////////////////////////////////////////// 
//                             
///////////////////////////////////////////////////////////// 

void main (void) 
{ 
    int Dec; 
    char Hex=0xFA; 
    Dec= Hex_To_Int(Hex,8); //convert an 8-bis hexadecimal value to a number in base 10 
    printf("the number is %d",Dec); 
} 

Answer 14

AVR microcontrollers के लिए मैं यह आसान समझने के लिए बनाने के लिए प्रासंगिक टिप्पणियां सहित निम्नलिखित समारोह ने लिखा है:

/** 
* hex2int 
* take a hex string and convert it to a 32bit number (max 8 hex digits) 
*/ 
uint32_t hex2int(char *hex) { 
    uint32_t val = 0; 
    while (*hex) { 
     // get current character then increment 
     char byte = *hex++; 
     // transform hex character to the 4bit equivalent number, using the ascii table indexes 
     if (byte >= '0' && byte <= '9') byte = byte - '0'; 
     else if (byte >= 'a' && byte <='f') byte = byte - 'a' + 10; 
     else if (byte >= 'A' && byte <='F') byte = byte - 'A' + 10;  
     // shift 4 to make space for new digit, and add the 4 bits of the new digit 
     val = (val << 4) | (byte & 0xF); 
    } 
    return val; 
} 

उदाहरण:

char *z ="82ABC1EF"; 
uint32_t x = hex2int(z); 
printf("Number is [%X]\n", x); 

विल उत्पादन:

Answer 15

सी में आप कई मायनों में दशमलव में एक हेक्साडेसिमल संख्या बदल सकते हैं। एक तरीका हेक्साडेसिमल संख्या को पूर्णांक में डालना है। मैंने व्यक्तिगत रूप से यह सरल और छोटा पाया।

कास्टिंग की सहायता से हेक्साडेसिमल संख्या को दशमलव संख्या में परिवर्तित करने के लिए एक नमूना कोड है।

#include <stdio.h> 

int main(){ 
    unsigned char Hexadecimal = 0x6D; //example hex number 
    int Decimal = 0; //decimal number initialized to 0 


     Decimal = (int) Hexadecimal; //conversion 

    printf("The decimal number is %d\n", Decimal); //output 
    return 0; 
}