C ++ में किस प्रकार का मान पूर्णांक स्टोर कर सकता है

Question

unsigned long int32-बिट कंप्यूटर पर दस अंकों की संख्या (1,000,000,000 - 9,999,999,999) रख सकते हैं?

साथ ही, की सीमाओं क्या कर रहे हैं unsigned long int, long int, unsigned int, short int, short unsigned int, और int?

Answer 1

कम से कम श्रेणियों पर भरोसा कर सकते हैं, वे हैं:

• short int तथा int : -32,767 से 32,767
• unsigned short int तथा unsigned int : 0 से 65,535
• long int: -2,147,483,647 से 2,147,483,647
• unsigned long int: 0 से 4,294,967,295

इसका मतलब यह है कि नहीं, किसी भी 10 अंकों की संख्या को स्टोर करने के लिए भरोसा long int नहीं किया जा सकता है। हालाँकि, long long intC99 C में C99 और C ++ में C के लिए एक बड़ा प्रकार पेश किया गया था (यह प्रकार अक्सर पुराने मानकों के लिए एक संकलक द्वारा विस्तार के रूप में भी समर्थित है जिसमें इसे शामिल नहीं किया गया था)। इस प्रकार की न्यूनतम सीमा, यदि आपका कंपाइलर इसका समर्थन करता है, तो यह है:

• long long int: -9,223,372,036,854,775,807 से 9,223,372,036,854,775,807
• unsigned long long int: 0 से 18,446,744,073,709,551,615

तो वह प्रकार काफी बड़ा होगा (फिर, यदि आपके पास उपलब्ध है)।

---

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

Comments

शीर्षक ने मूल रूप से "C / C ++" भी कहा।

— कैफे

क्यों लंबी लंबी सकारात्मक सीमा == नकारात्मक सीमा

— मुहम्मद अब्दुल्ला

@mohamedabdallah: उत्तर के अंतिम पैराग्राफ को देखें: C मानक श्रेणियां वे हैं जो लोगों के पूरक या साइन-परिमाण अभ्यावेदन के लिए अनुमति देती हैं।

— कैफे

अहा..मुझे एहसास हुआ कि intमतलब long int।

— mazend

Answer 2

संख्यात्मक प्रकारों का आकार C ++ मानक में परिभाषित नहीं है, हालांकि न्यूनतम आकार हैं। यह बताने का तरीका कि वे आपके प्लेटफ़ॉर्म पर किस आकार के हैं, संख्यात्मक सीमा का उपयोग करना है

उदाहरण के लिए, एक इंट के लिए अधिकतम मूल्य द्वारा पाया जा सकता है:

std::numeric_limits<int>::max();

कंप्यूटर बेस 10 में काम नहीं करते हैं, जिसका अर्थ है कि अधिकतम मान 2 ⁿ -1 के रूप में होगा क्योंकि मेमोरी में संख्याओं का प्रतिनिधित्व कैसे किया जाता है। उदाहरण के लिए आठ बिट्स (1 बाइट) लें

  0100 1000

दाएं सबसे थोड़ा (संख्या) जब सेट 1 पर 2 ^{0 का} प्रतिनिधित्व करता है , तो अगला बिट 2 ^{1 का} , फिर 2 ² और इसी तरह से जब तक हम बाईं ओर नहीं पहुंचते हैं, यदि संख्या अहस्ताक्षरित है तो 2 ^{7 का} प्रतिनिधित्व करता है ।

तो संख्या 2 ⁶ + 2 ³ = 64 + 8 = 72 का प्रतिनिधित्व करती है , क्योंकि दाईं ओर से 4 बिट और बाईं ओर 7 वें बिट सेट हैं।

यदि हम सभी मानों को 1 पर सेट करते हैं:

11111111

संख्या अब ( अहस्ताक्षरित मानकर )
128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255 = 2 ⁸ - 1
और जैसा कि हम देख सकते हैं, यह सबसे बड़ा संभव मूल्य है जिसे 8 बिट्स के साथ दर्शाया जा सकता है।

मेरी मशीन पर और इंट और एक लंबे समय तक समान हैं, प्रत्येक -2 ³¹ से 2 ^{31 के} बीच रखने में सक्षम हैं - 1. मेरे अनुभव में आधुनिक 32 बिट डेस्कटॉप मशीन पर सबसे आम आकार है।

Comments

पूर्णांक प्रकार के लिए न्यूनतम आकार प्रासंगिक मानकों (हालांकि सटीक आकार नहीं हैं) द्वारा अनिवार्य हैं।

— कैफे

Answer 3

अपने सिस्टम की सीमाओं का पता लगाने के लिए :

#include <iostream>
#include <limits>
int main(int, char **) {
  std::cout
    << static_cast< int >(std::numeric_limits< char >::max()) << "\n"
    << static_cast< int >(std::numeric_limits< unsigned char >::max()) << "\n"
    << std::numeric_limits< short >::max() << "\n"
    << std::numeric_limits< unsigned short >::max() << "\n"
    << std::numeric_limits< int >::max() << "\n"
    << std::numeric_limits< unsigned int >::max() << "\n"
    << std::numeric_limits< long >::max() << "\n"
    << std::numeric_limits< unsigned long >::max() << "\n"
    << std::numeric_limits< long long >::max() << "\n"
    << std::numeric_limits< unsigned long long >::max() << "\n";
}

ध्यान दें कि long longकेवल C99 में और C ++ 11 में कानूनी है।

Answer 4

यहाँ अन्य लोग data_sizes और precisions आदि के लिए लिंक पोस्ट करेंगे।
मैं आपको यह बताने जा रहा हूं कि यह कैसे पता लगाना है।
एक छोटा सा ऐप लिखें जो निम्नलिखित कार्य करेगा।

unsigned int ui;
std::cout <<  sizeof(ui));

यह होगा (संकलक और अभिलेख के आधार पर) 2, 4 या 8 प्रिंट, 2 बाइट्स लंबे, 4 बाइट्स लंबे आदि।

मान लेते हैं कि यह 4 है।

अब आप चाहते हैं कि अधिकतम मूल्य 4 बाइट्स स्टोर कर सकें, एक बाइट के लिए अधिकतम मूल्य (हेक्स में) 0xFF है। चार बाइट्स का अधिकतम मूल्य 0x है, इसके बाद 8 f's (प्रत्येक बाइट के लिए f की एक जोड़ी, 0x कंपाइलर को बताता है कि निम्नलिखित स्ट्रिंग एक हेक्स संख्या है)। अब उस मान को असाइन करने और परिणाम प्रिंट करने के लिए अपना कार्यक्रम बदलें

unsigned int ui = 0xFFFFFFFF;
std::cout <<  ui;

आधार मान जो एक अहस्ताक्षरित int पकड़ सकता है, आधार 10 प्रतिनिधित्व में दिखाया गया है।

अब लंबे समय तक, शॉर्ट्स और किसी भी अन्य INTEGER मूल्य के बारे में आप उत्सुक हैं।

एनबी: यह दृष्टिकोण फ्लोटिंग पॉइंट नंबरों (यानी डबल या फ्लोट) के लिए काम नहीं करेगा।

उम्मीद है की यह मदद करेगा

Comments

यदि आप साइन इन किए गए इनट्स के साथ यह कोशिश करते हैं, तो आपको नकारात्मक संख्याएं मिलती हैं। "दो की प्रशंसा" (लिंक प्रदान की गई) पर पढ़ें, इन के लिए भी पूर्ण सीमा (सकारात्मक और नकारात्मक) प्राप्त करना आसान है। en.wikipedia.org/wiki/Twos_Compliment

— बाइनरी वॉरियर

Answer 5

C ++ में, अब int और अन्य डेटा 2 की तारीफ विधि का उपयोग करके संग्रहीत किया जाता है। इसका मतलब है कि सीमा है:

-2147483648 to 2147483647

या -2 ^ 31 से 2 ^ 31-1

1 बिट 0 के लिए आरक्षित है इसलिए सकारात्मक मान 2 ^ (31) से कम है

Answer 6

आप हेडर फ़ाइल में मौजूद numeric_limits<data_type>::min()और numeric_limits<data_type>::max()फ़ंक्शंस का उपयोग कर सकते हैं और limitsप्रत्येक डेटा प्रकार की सीमा पा सकते हैं।

#include <iostream>
#include <limits>
using namespace std;
int main()
{
    cout<<"Limits of Data types:\n";    
    cout<<"char\t\t\t: "<<static_cast<int>(numeric_limits<char>::min())<<" to "<<static_cast<int>(numeric_limits<char>::max())<<endl;
    cout<<"unsigned char\t\t: "<<static_cast<int>(numeric_limits<unsigned char>::min())<<" to "<<static_cast<int>(numeric_limits<unsigned char>::max())<<endl;
    cout<<"short\t\t\t: "<<numeric_limits<short>::min()<<" to "<<numeric_limits<short>::max()<<endl;
    cout<<"unsigned short\t\t: "<<numeric_limits<unsigned short>::min()<<" to "<<numeric_limits<unsigned short>::max()<<endl;
    cout<<"int\t\t\t: "<<numeric_limits<int>::min()<<" to "<<numeric_limits<int>::max()<<endl;
    cout<<"unsigned int\t\t: "<<numeric_limits<unsigned int>::min()<<" to "<<numeric_limits<unsigned int>::max()<<endl;
    cout<<"long\t\t\t: "<<numeric_limits<long>::min()<<" to "<<numeric_limits<long>::max()<<endl;
    cout<<"unsigned long\t\t: "<<numeric_limits<unsigned long>::min()<<" to "<<numeric_limits<unsigned long>::max()<<endl;
    cout<<"long long\t\t: "<<numeric_limits<long long>::min()<<" to "<<numeric_limits<long long>::max()<<endl;
    cout<<"unsiged long long\t: "<<numeric_limits<unsigned long long>::min()<<" to "<<numeric_limits<unsigned long long>::max()<<endl;
    cout<<"float\t\t\t: "<<numeric_limits<float>::min()<<" to "<<numeric_limits<float>::max()<<endl;
    cout<<"double\t\t\t: "<<numeric_limits<double>::min()<<" to "<<numeric_limits<double>::max()<<endl;
    cout<<"long double\t\t: "<<numeric_limits<long double>::min()<<" to "<<numeric_limits<long double>::max()<<endl;
}

आउटपुट होगा: डेटा प्रकार की सीमाएं:

• char: -128 से 127
• अहस्ताक्षरित चार: 0 से 255
• संक्षेप: -32768 से 32767
• अहस्ताक्षरित लघु: 0 से 65535
• int: -2147483648 से 2147483647
• अहस्ताक्षरित int: 0 से 4294967295
• लंबा: -2147483648 से 2147483647
• अहस्ताक्षरित लंबा: 0 से 4294967295
• लंबे समय तक: -9223372036854775808 से 9223372036854775807
• अहस्ताक्षरित लंबा लंबा: 0 से 18446744073709551615
• फ्लोट: 1.17549e-038 से 3.40282e + 038
• डबल: 2.22507e-308 से 1.79769e + 308
• लंबी डबल: 3.3621e-4932 से 1.18973e + 4932

Answer 7

के लिए अहस्ताक्षरित डेटा प्रकार वहाँ कोई संकेत नहीं बिट है और सभी बिट्स डेटा के लिए कर रहे हैं; जबकि हस्ताक्षरित डेटा प्रकार के लिए MSB को संकेत बिट और शेष बिट्स को डेटा के लिए संकेत दिया जाता है।

निम्नलिखित चीजों को करने के लिए सीमा खोजें:

चरण: 1 -> डेटा प्रकार देने के लिए बाइट्स का पता लगाएं।

चरण: 2 -> निम्नलिखित गणना लागू करें।

      Let n = no of bits in data type  

      For signed data type ::
            Lower Range = -(2^(n-1)) 
            Upper Range = (2^(n-1)) - 1)  

      For unsigned data type ::
            Lower Range = 0 
            Upper Range = (2^(n)) - 1 

उदाहरण के लिए

अहस्ताक्षरित अंतर आकार के लिए = 4 बाइट्स (32 बिट्स) -> रेंज [0, (2 ^ (32)) - 1]

हस्ताक्षरित अंतर आकार के लिए = 4 बाइट्स (32 बिट्स) -> रेंज [- (2 ^ (32-1)), (2 ^ (32-1)) - 1]

Answer 8

अहस्ताक्षरित लंबे समय तक एक 32-बिट कंप्यूटर पर दस अंकों की संख्या (1,000,000,000 - 9,999,999,999) हो सकती है।

नहीं

Answer 9

नहीं, केवल दस अंकों की संख्या का एक हिस्सा एक अहस्ताक्षरित लंबे इंट में संग्रहीत किया जा सकता है जिसकी वैध सीमा 0 से 4,294,967,295 है। आप इसका उल्लेख कर सकते हैं: http://msdn.microsoft.com/en-us/library/s3f49ktz(VS.80).aspx

Answer 10

आपको किसी दिए गए प्रकार के संख्यात्मक_आल्ट्स <> के विशेषणों को देखना चाहिए। हेडर में इसकी।