दिलचस्प पोस्ट
ऑर्डर के साथ ऑब्जेक्ट की चाबी कैसे फ़िल्टर करें? मैं यह जेबटन कैसे दिख सकता हूं? जब मुझे प्रगतिशील स्कैन पृष्ठभूमि JWindow () है? लंबे डबल बनाम डबल जावा 8: मैं धाराओं में अपवाद फेंकने के तरीकों के साथ कैसे काम करूं? गिट: एक ही बार में कई शाखाओं को कैसे दुबारा बांटने के लिए? यह निर्धारित करने के लिए कि किस निर्भरता Google Play OpenSSL चेतावनी का कारण बनती है? स्नैपशॉट दृश्य में फ़ाइलों की स्थानीय प्रतिलिपि खोजें पॉपअप अवरोधक को खिड़की पर बायपास करें। जब JQuery event.preventDefault () सेट किया जाता है ListView कस्टम पंक्ति लेआउट के किसी आइटम पर onClick () ईवेंट के बारे में सहायता कॉल स्टैक से फ़ंक्शन नाम प्राप्त करें libstdc ++ – 6.dll नहीं मिला बहुआयामी सरणी सिकुड़ने वाली कुंजी को चिपकाएं mysql :: तालिका में डालें, दूसरे तालिका से डेटा? प्रत्येक variadic टेम्पलेट तर्क और एक सरणी के लिए एक समारोह कॉलिंग सरणी के arrays.asList ()

कन्वर्ट करने के लिए चार में सी int और सी ++

मैं सी और सी ++ में एक int को कैसे बदल सकता हूँ?

Solutions Collecting From Web of "कन्वर्ट करने के लिए चार में सी int और सी ++"

निर्भर करता है कि आपकी क्या करने की इच्छा है:

एक ascii कोड के रूप में मान पढ़ने के लिए, आप लिख सकते हैं

 char a = 'a'; int ia = (int)a; /* note that the int cast is not necessary -- int ia = a would suffice */ 

वर्ण '0' -> 0 , '1' -> 1 , आदि को बदलने के लिए, आप लिख सकते हैं

 char a = '4'; int ia = a - '0'; /* check here if ia is bounded by 0 and 9 */ 

सी और सी ++ हमेशा कम से कम int पर प्रकारों को बढ़ावा देते हैं इसके अलावा चरित्र लिटरल सी में सी प्रकार और सी में C ++ के होते हैं

आप बस एक int निर्दिष्ट करने के लिए एक char प्रकार के रूप में कनवर्ट कर सकते हैं।

 char c = 'a'; // narrowing on C int a = c; 

अच्छी तरह से, आस्सी कोड संख्या में 48 से शुरू होते हैं। आपको बस इतना करना होगा:

 int x = (int)character - 48; 

चार सिर्फ एक 1 बाइट पूर्णांक है चार प्रकार के साथ जादू नहीं है! जैसे कि आप किसी इंट, या लंबे समय तक एक इंट के लिए एक छोटा आवंटित कर सकते हैं, आप एक इंट को चारों ओर आवंटित कर सकते हैं।

हां, आदिम डेटा प्रकार का नाम "चार" होता है, जो इन्हें बताता है कि इसमें केवल वर्ण होने चाहिए लेकिन हकीकत में, "चार" केवल उन सभी लोगों को भ्रमित करने के लिए एक खराब नाम चुना जाता है जो भाषा सीखने की कोशिश करते हैं। इसके लिए एक बेहतर नाम int8_t है, और आप इसके बजाय उस नाम का उपयोग कर सकते हैं, यदि आपका कंपाइलर नवीनतम सी मानक का पालन करता है

हालांकि निश्चित रूप से स्टैंग हैंडलिंग करते समय आपको चार प्रकार का उपयोग करना चाहिए , क्योंकि क्लासिक एएससीआईआई तालिका का सूचक 1 बाइट में फिट होता है आप हालांकि, नियमित रूप से नियमित रूप से कमियों के साथ स्ट्रिंग हैंडलिंग कर सकते हैं , हालांकि वास्तविक दुनिया में कोई व्यावहारिक कारण नहीं है कि आप ऐसा क्यों करना चाहते हैं उदाहरण के लिए, निम्नलिखित कोड पूरी तरह से कार्य करेगा:

  int str[] = {'h', 'e', 'l', 'l', 'o', '\0' }; for(i=0; i<6; i++) { printf("%c", str[i]); } 

आपको यह एहसास करना होगा कि अक्षर और तार केवल संख्याएं हैं, जैसे कंप्यूटर में सब कुछ जब आप स्रोत कोड में 'ए' लिखते हैं, तो यह संख्या 97 में पूर्व-संसाधित होती है, जो एक पूर्णांक स्थिरांक है

तो अगर आप जैसे अभिव्यक्ति लिखते हैं

 char ch = '5'; ch = ch - '0'; 

यह वास्तव में इसके बराबर है

 char ch = (int)53; ch = ch - (int)48; 

जो तब सी भाषा पूर्णांक पदोन्नति के माध्यम से जा रहा है

 ch = (int)ch - (int)48; 

और फिर परिणाम प्रकार को फिट करने के लिए एक चार में छोटा किया

 ch = (char)( (int)ch - (int)48 ); 

ऐसी बहुत सारी सूक्ष्म चीजें हैं, जैसे कि लाइनों के बीच चल रही है, जहां पर चारों को एक int के रूप में माना जाता है

(यह उत्तर सी + + चीजों की तरफ देता है, लेकिन सी एक्सटेंशन एक्सटेंशन समस्या भी सी में मौजूद है।)

सभी तीन प्रकार के प्रकार (हस्ताक्षरित, अहस्ताक्षरित, और "चार") को संभालने से यह सबसे पहले नाजुक होता है। श्रेणी 0 से लेकर SCHAR_MAX (जो कि 8-बिट के लिए 127 है) के लिए आसान हैं:

 char c = somevalue; signed char sc = c; unsigned char uc = c; int n = c; 

लेकिन जब किसी प्रकार की सीमा उस सीमा से बाहर होती है, तो केवल अहस्ताक्षरित चारों ओर जाकर आप सभी तीन प्रकारों में "समान" चार मानों के लिए लगातार परिणाम देते हैं:

 char c = somevalue; signed char sc = c; unsigned char uc = c; // Might not be true: int(c) == int(sc) and int(c) == int(uc). int nc = (unsigned char)c; int nsc = (unsigned char)sc; int nuc = (unsigned char)uc; // Always true: nc == nsc and nc == nuc. 

साइन एक्स्टेंशन के कारण <ctype> से फ़ंक्शन का उपयोग करते समय यह महत्वपूर्ण है, जैसे कि आइसप्पर या टूपर,

 char c = negative_char; // Assuming CHAR_MIN < 0. int n = c; bool b = isupper(n); // Undefined behavior. 

अंतर के माध्यम से रूपांतरण पर ध्यान दें; यह एक ही यूबी है:

 char c = negative_char; bool b = isupper(c); 

इसे ठीक करने के लिए, अहस्ताक्षरित चारों के माध्यम से जाओ, जो आसानी से < ctype > फ़ंक्शन को सुरक्षित_कट्य के माध्यम से लपेटकर किया जाता है:

 template<int (&F)(int)> int safe_ctype(unsigned char c) { return F(c); } //... char c = CHAR_MIN; bool b = safe_ctype<isupper>(c); // No UB. std::string s = "value that may contain negative chars; eg user input"; std::transform(s.begin(), s.end(), s.begin(), &safe_ctype<toupper>); // Must wrap toupper to eliminate UB in this case, you can't cast // to unsigned char because the function is called inside transform. 

यह काम करता है क्योंकि किसी भी कार्य में से कोई भी तीन प्रकार के अन्य प्रकारों को ले कर अन्य दो प्रकार के प्रकार भी ले सकता है। यह दो कार्यों की ओर जाता है जो किसी भी प्रकार को संभाल सकते हैं:

 int ord(char c) { return (unsigned char)c; } char chr(int n) { assert(0 <= n); // Or other error-/sanity-checking. assert(n <= UCHAR_MAX); return (unsigned char)n; } // Ord and chr are named to match similar functions in other languages // and libraries. 

Ord (c) हमेशा आपको एक गैर-नकारात्मक मूल्य देता है – यहां तक ​​कि जब एक नकारात्मक वर्ण या नकारात्मक हस्ताक्षरित वर्ण पारित किया जाता है – और chr किसी भी मान ord उत्पादन करता है और सटीक समान चार वापस देता है

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

यह किस प्रकार आपके द्वारा "कन्वर्ट" से क्या मतलब है पर निर्भर करता है

यदि आपके पास एक ऐसा वर्ण है जो एक पूर्णांक का प्रतिनिधित्व करता है, जैसे "123456", तो सी में ऐसा करने के दो विशिष्ट तरीके हैं: विशेष उद्देश्य रूपांतरण जैसे atoi () या strtol () , या सामान्य प्रयोजन sscanf () सी ++ (जो वास्तव में उन्नयन के रूप में एक अलग भाषा है) तीसरी, स्ट्रिंग स्ट्रीम

यदि आप का मतलब है कि आप अपने चर चर में से एक में सटीक बिट पैटर्न चाहते हैं जिसे char रूप में माना जाए, तो यह आसान है सी में विभिन्न पूर्णांक प्रकार वास्तव में अलग-अलग "प्रकारों" की तुलना में मन की स्थिति का अधिक है बस उस स्थान का उपयोग करना शुरू करें जहां char लिए पूछा जाता है, और आपको ठीक होना चाहिए। आपको एक विशिष्ट रूपांतरण की आवश्यकता हो सकती है ताकि संकलक को अवसर पर रोने के लिए छोड़ दिया जाए, लेकिन जो भी करना चाहिए, वह 256 के अतिरिक्त किसी भी अतिरिक्त बिट को छोड़ दें।

static_cast<int> प्रयोग करें:

 int num = static_cast<int>(letter); // if letter='a', num=97 

संपादित करें: आप शायद उपयोग करने से बचने की कोशिश करनी चाहिए (int)

int num = (int) अक्षर;

चेक करें क्यों (int) x के बजाय static_cast <int> (x) का उपयोग करें? अधिक जानकारी के लिए।

संभवतः आप सी मानक लाइब्रेरी से फ़ंक्शन का उपयोग करने के लिए यह रूपांतरण चाहते हैं।

उस स्थिति में, (सी ++ सिंटैक्स) करें

 typedef unsigned char UChar; char myCppFunc( char c ) { return char( someCFunc( UChar( c ) ) ); } 

अभिव्यक्ति UChar( c ) नकारात्मक मानों से छुटकारा पाने के लिए unsigned char को परिवर्तित करती है, जो UChar( c ) को छोड़कर, सी फ़ंक्शंस द्वारा समर्थित नहीं हैं।

तब उस अभिव्यक्ति का परिणाम एक int तर्क के लिए वास्तविक तर्क के रूप में प्रयोग किया जाता है। जहां आप को int लिए स्वचालित पदोन्नति मिलती है आप वैकल्पिक रूप से उस आखिरी चरण को स्पष्ट रूप से लिख सकते हैं, जैसे कि int( UChar( c ) ) , लेकिन व्यक्तिगत रूप से मुझे लगता है कि बहुत ही int( UChar( c ) )

चीयर्स & hth।,

मेरे पास सी में बिल्कुल null कौशल है, लेकिन एक साधारण पार्सिंग के लिए:

 char* something = "123456"; int number = parseInt(something); 

… यह मेरे लिए काम किया:

 int parseInt(char* chars) { int sum = 0; int len = strlen(chars); for (int x = 0; x < len; x++) { int n = chars[len - (x + 1)] - '0'; sum = sum + pow(n, x); } return sum; } int powInt(int x, int y) { for (int i = 0; i < y; i++) { x *= 10; } return x; } 

मुझे "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e" जैसे एक चार सरणी को अपने वास्तविक पूर्णांक मान में परिवर्तित करने में समस्याएं "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e" जो एक हेक्साडेसिमल मान के रूप में `7C 'द्वारा प्रतिनिधित्व करने में सक्षम हो "7c7c7d7d7d7d7c7c7c7d7d7d7d7c7c7c7c7c7c7d7d7c7c7c7c7d7c7d7d7d7c7c2e2e2e" इसलिए, मदद के लिए दौड़ने के बाद मैंने इसे बनाया और सोचा कि यह साझा करने के लिए अच्छा होगा।

यह अपने सही पूर्णांक में चार स्ट्रिंग को अलग करता है, और सिर्फ मुझसे ज्यादा लोगों के लिए सहायक हो सकता है;)

 unsigned int* char2int(char *a, int len) { int i,u; unsigned int *val = malloc(len*sizeof(unsigned long)); for(i=0,u=0;i<len;i++){ if(i%2==0){ if(a[i] <= 57) val[u] = (a[i]-50)<<4; else val[u] = (a[i]-55)<<4; } else{ if(a[i] <= 57) val[u] += (a[i]-50); else val[u] += (a[i]-55); u++; } } return val; } 

आशा करता हूँ की ये काम करेगा!

चार या पूर्णांक के लिए छोटा करने के लिए, आपको केवल मूल्य निर्दिष्ट करना होगा।

 char ch = 16; int in = ch; 

Int64 के समान

 long long lo = ch; 

सभी मान 16 होंगे।