कन्वर्ट हेक्स स्ट्रिंग (चार []] int करने के लिए?

Question 1

मेरे पास एक चार [] है जिसमें "0x1800785" जैसे मान शामिल हैं, लेकिन जिस फ़ंक्शन को मैं एक इंट की आवश्यकता के लिए मूल्य देना चाहता हूं, मैं इसे एक इंट में कैसे बदल सकता हूं? मैंने चारों ओर खोज की है, लेकिन उत्तर नहीं मिल रहा है। धन्यवाद।

Question 2

क्या आपने कोशिश की है strtol()?

strtol - स्ट्रिंग को एक लंबे पूर्णांक में परिवर्तित करें

उदाहरण:

const char *hexstring = "abcdef0";
int number = (int)strtol(hexstring, NULL, 16);

यदि संख्या का स्ट्रिंग प्रतिनिधित्व एक 0xउपसर्ग के साथ शुरू होता है , तो एक को आधार के रूप में 0 का उपयोग ~~करना~~ चाहिए:

const char *hexstring = "0xabcdef0";
int number = (int)strtol(hexstring, NULL, 0);

(यह एक स्पष्ट आधार निर्दिष्ट करना संभव है जैसे कि 16, लेकिन मैं अतिरेक पेश करने की सिफारिश नहीं करूंगा।)

Question 3

या यदि आप अपना स्वयं का कार्यान्वयन करना चाहते हैं, तो मैंने इस त्वरित कार्य को एक उदाहरण के रूप में लिखा:

/**
 * 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
        uint8_t 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;
}

Question 4

कुछ इस तरह उपयोगी हो सकता है:

char str[] = "0x1800785";
int num;

sscanf(str, "%x", &num);
printf("0x%x %i\n", num, num);

आदमी sscanf पढ़ें

Question 5

आप मानते हैं कि यह एक स्ट्रिंग है, स्ट्रेटोल के बारे में कैसे ?

Question 6

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

#include <inttypes.h>


/**
 * xtou64
 * Take a hex string and convert it to a 64bit number (max 16 hex digits).
 * The string must only contain digits and valid hex characters.
 */
uint64_t xtou64(const char *str)
{
    uint64_t res = 0;
    char c;

    while ((c = *str++)) {
        char v = (c & 0xF) + (c >> 6) | ((c >> 3) & 0x8);
        res = (res << 4) | (uint64_t) v;
    }

    return res;
}

बिट शिफ्टिंग मैजिक फोड़े को नीचे लाती है: बस अंतिम 4 बिट्स का उपयोग करें, लेकिन यदि यह एक गैर अंक है, तो 9 भी जोड़ें।

Question 7

कोड के ब्लॉक के नीचे की कोशिश करो, मेरे लिए काम कर रहा है।

char *p = "0x820";
uint16_t intVal;
sscanf(p, "%x", &intVal);

printf("value x: %x - %d", intVal, intVal);

आउटपुट है:

value x: 820 - 2080

Question 8

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

int hexToInt(PCHAR _hex, int offset = 0, int size = 6)
{
    int _result = 0;
    DWORD _resultPtr = reinterpret_cast<DWORD>(&_result);
    for(int i=0;i<size;i+=2)
    {
        int _multiplierFirstValue = 0, _addonSecondValue = 0;

        char _firstChar = _hex[offset + i];
        if(_firstChar >= 0x30 && _firstChar <= 0x39)
            _multiplierFirstValue = _firstChar - 0x30;
        else if(_firstChar >= 0x41 && _firstChar <= 0x46)
            _multiplierFirstValue = 10 + (_firstChar - 0x41);

        char _secndChar = _hex[offset + i + 1];
        if(_secndChar >= 0x30 && _secndChar <= 0x39)
            _addonSecondValue = _secndChar - 0x30;
        else if(_secndChar >= 0x41 && _secndChar <= 0x46)
            _addonSecondValue = 10 + (_secndChar - 0x41);

        *(BYTE *)(_resultPtr + (size / 2) - (i / 2) - 1) = (BYTE)(_multiplierFirstValue * 16 + _addonSecondValue);
    }
    return _result;
}

उपयोग:

char *someHex = "#CCFF00FF";
int hexDevalue = hexToInt(someHex, 1, 8);

1 क्योंकि हम जिस हेक्स को बदलना चाहते हैं वह ऑफसेट 1 और 8 से शुरू होता है क्योंकि यह हेक्स की लंबाई है।

स्पीडटेस्ट (1.000.000 कॉल):

strtol ~ 0.4400s
hexToInt ~ 0.1100s

Question 9

एक त्वरित और गंदा समाधान:

// makes a number from two ascii hexa characters
int ahex2int(char a, char b){

    a = (a <= '9') ? a - '0' : (a & 0x7) + 9;
    b = (b <= '9') ? b - '0' : (b & 0x7) + 9;

    return (a << 4) + b;
}

आपको यह सुनिश्चित करना होगा कि आपका इनपुट सही है, कोई सत्यापन शामिल नहीं है (कोई कह सकता है कि यह C है)। अच्छी बात यह काफी कॉम्पैक्ट है, यह 'ए' से 'एफ' और 'ए' से 'एफ' दोनों के साथ काम करता है।

दृष्टिकोण ASCII तालिका में वर्णमाला वर्णों की स्थिति पर निर्भर करता है, चलो उदाहरण के लिए Wikipedia ( https://en.wikipedia.org/wiki/ASCII#/media/File:USASCII_code_chart.png ) पर जाएं ) पर । लंबी कहानी छोटी, संख्या वर्णों के नीचे होती है, इसलिए संख्यात्मक वर्ण (0 से 9) आसानी से शून्य के लिए कोड घटाकर बदल दिए जाते हैं। पिछले तीन बिट्स (प्रभावी रूप से ऊपरी या निचले हिस्से के साथ काम करना), एक को घटाकर (क्योंकि बिट मास्किंग के बाद, वर्णमाला एक स्थिति पर शुरू होती है) और दस को जोड़ने के अलावा अन्य अक्षर (ए से एफ) पढ़े जाते हैं। क्योंकि A से F हेक्साडेसिमल कोड में 10 वें से 15 वें मूल्य का प्रतिनिधित्व करता है)। अंत में, हमें दो अंकों को संयोजित करने की आवश्यकता है जो एन्कोडेड संख्या के निचले और ऊपरी कुतरना बनाते हैं।

यहाँ हम एक ही दृष्टिकोण के साथ जाते हैं (मामूली बदलाव के साथ):

#include <stdio.h>

// takes a null-terminated string of hexa characters and tries to 
// convert it to numbers
long ahex2num(unsigned char *in){

    unsigned char *pin = in; // lets use pointer to loop through the string
    long out = 0;  // here we accumulate the result

    while(*pin != 0){
        out <<= 4; // we have one more input character, so 
                   // we shift the accumulated interim-result one order up
        out +=  (*pin < 'A') ? *pin & 0xF : (*pin & 0x7) + 9; // add the new nibble
        pin++; // go ahead
    }

    return out;
}

// main function will test our conversion fn
int main(void) {

    unsigned char str[] = "1800785";  // no 0x prefix, please
    long num;

    num = ahex2num(str);  // call the function

    printf("Input: %s\n",str);  // print input string
    printf("Output: %x\n",num);  // print the converted number back as hexa
    printf("Check: %ld = %ld \n",num,0x1800785);  // check the numeric values matches

    return 0;
}

Question 10

यह हेक्साडेसिमल युक्त वर्ण को सीधे एक पूर्णांक में बदलने के लिए एक फ़ंक्शन है जिसे अतिरिक्त पुस्तकालय की आवश्यकता नहीं है:

int hexadecimal2int(char *hdec) {
    int finalval = 0;
    while (*hdec) {
        
        int onebyte = *hdec++; 
        
        if (onebyte >= '0' && onebyte <= '9'){onebyte = onebyte - '0';}
        else if (onebyte >= 'a' && onebyte <='f') {onebyte = onebyte - 'a' + 10;}
        else if (onebyte >= 'A' && onebyte <='F') {onebyte = onebyte - 'A' + 10;}  
        
        finalval = (finalval << 4) | (onebyte & 0xF);
    }
    finalval = finalval - 524288;
    return finalval;
}

Question 11

मैंने हेक्साडेसिमल / डेसीमल रूपांतरण का उपयोग किए बिना एक लीब्राएरी बनाया stdio.h। उपयोग करने के लिए बहुत सरल:

unsigned hexdec (const char *hex, const int s_hex);

पहले रूपांतरण से पहले रूपांतरण के लिए उपयोग की गई सारणी को पहले से बताएं:

void init_hexdec ();

यहाँ github पर लिंक: https://github.com/kevmuret/libhex/

Question 12

मैं एक ऐसी ही बात किया है, लगता है कि यह मदद कर सकता है यू वास्तव में मेरे लिए काम कर रहा है

int main(){ int co[8],i;char ch[8];printf("please enter the string:");scanf("%s",ch);for(i=0;i<=7;i++){if((ch[i]>='A')&&(ch[i]<='F')){co[i]=(unsigned int)ch[i]-'A'+10;}else if((ch[i]>='0')&&(ch[i]<='9')){co[i]=(unsigned int)ch[i]-'0'+0;}}

यहाँ मैंने केवल 8 वर्णों का एक स्ट्रिंग लिया है। यदि आप चाहते हैं कि यू अपने समान हेक्स मान देने के लिए 'ए' से 'एफ' के लिए समान तर्क जोड़ सकते हैं, तो मैंने ऐसा नहीं किया है क्योंकि मुझे इसकी आवश्यकता नहीं थी।

Question 13

मुझे पता है कि यह वास्तव में पुराना है, लेकिन मुझे लगता है कि समाधान बहुत जटिल लग रहे थे। VB में यह प्रयास करें:

Public Function HexToInt(sHEX as String) as long
Dim iLen as Integer
Dim i as Integer 
Dim SumValue as Long 
Dim iVal as long
Dim AscVal as long

    iLen = Len(sHEX)
    For i = 1 to Len(sHEX)
      AscVal = Asc(UCase(Mid$(sHEX, i,  1)))
      If AscVal >= 48 And AscVal  <= 57 Then
        iVal  = AscVal - 48
      ElseIf AscVal >= 65 And AscVal <= 70 Then
        iVal = AscVal - 55
      End If 
      SumValue = SumValue + iVal * 16 ^ (iLen- i)
    Next i 
    HexToInt  = SumValue
End Function