सी ++ वैरिएबल प्रकार

Question

को सीमित करता है यहाँ एक काफी सरल सवाल (मुझे लगता है कि) है, वहाँ कि एक चर प्रकार(उदाहरण, पूर्णांक)की सीमा प्रदान करता है एक एसटीएल पुस्तकालय विधि है? मुझे पता है कि ये सीमाएं अलग-अलग कंप्यूटरों पर भिन्न होती हैं लेकिन उन्हें विधि के माध्यम से प्राप्त करने का एक तरीका होना चाहिए, है ना?

इसके अलावा, एक चर प्रकार के सीमा की गणना करने के लिए एक विधि लिखना वाकई मुश्किल होगा?

मैं बस उत्सुक हूँ! :)

धन्यवाद;)।

Answer 1

उपयोग std::numeric_limits:

// numeric_limits example 
// from the page I linked 
#include <iostream> 
#include <limits> 
using namespace std; 

int main() { 
    cout << boolalpha; 
    cout << "Minimum value for int: " << numeric_limits<int>::min() << endl; 
    cout << "Maximum value for int: " << numeric_limits<int>::max() << endl; 
    cout << "int is signed: " << numeric_limits<int>::is_signed << endl; 
    cout << "Non-sign bits in int: " << numeric_limits<int>::digits << endl; 
    cout << "int has infinity: " << numeric_limits<int>::has_infinity << endl; 
    return 0; 
} 

Answer 2

(सी से जुड़े हैं, लेकिन मुझे लगता है कि यह भी सी ++ के लिए लागू होता है)

तुम भी "enquire" कोशिश कर सकते हैं, जो एक स्क्रिप्ट जो सीमा पुन: बना सकते है आपके कंपाइलर के लिए। projetc के मुख पृष्ठ से एक उद्धरण:

यह एक प्रोग्राम है जो इस तरह के न्यूनतम और अधिकतम [संयुक्त राष्ट्र] पर हस्ताक्षर किए चार/पूर्णांक के रूप में सी संकलक के कई गुण और मशीन है कि उस पर चलाया जाता है, निर्धारित करता है/लंबे, फ्लोट/[लंबे] डबल, और इतने पर कई गुण।

एक विकल्प के रूप में यह एएनएसआई सी float.h और limit.h फ़ाइलों का उत्पादन करता है।

एक और विकल्प के रूप में, यह भी जांचता है कि संकलक फ़ाइलों को सही ढंग से पढ़ता है।

यह compilers के लिए एक अच्छा परीक्षण मामला है, के बाद से यह उन्हें ऐसे न्यूनतम और अधिकतम चल बिन्दु संख्या के रूप में कई सीमित मूल्यों, साथ प्रयोग करता है।

Answer 3

#include <limits> 

std::numeric_limits<type>::max() // min() etc 

Answer 4

मुझे लगता है कि 'सही' जवाब पहले से ही दिया गया है: उपयोग <limits> और जादू होने दें। मुझे यह जवाब असंतुष्ट लगता है, क्योंकि सवाल यह है कि:

एक चर प्रकार के सीमा की गणना करने के लिए एक विधि लिखना वाकई मुश्किल होगा?

उत्तर है: पूर्ण प्रकार के लिए आसान, फ्लोट प्रकारों के लिए कठिन। 3 मूल प्रकार के एल्गोरिदम हैं जिन्हें आपको करने की आवश्यकता होगी। हस्ताक्षरित, हस्ताक्षरित, और तैरने बिंदु। प्रत्येक के पास एक छोटा एल्गोरिदम होता है कि आप कैसे न्यूनतम और अधिकतम प्राप्त करते हैं, और वास्तविक कोड में थोड़ा सा झुकाव होता है, और फ्लोटिंग पॉइंट के मामले में, आपको लूप करना पड़ता है जब तक कि आपके पास एक ज्ञात पूर्णांक प्रकार न हो जो फ़्लोट के समान आकार हो प्रकार।

तो, यह यहां है।

बिना हस्ताक्षर करना आसान है। न्यूनतम तब होता है जब सभी बिट्स 0 होते हैं, अधिकतम तब होता है जब सभी बिट्स 1 होते हैं।

const unsigned type unsigned_type_min = (unsigned type)0;  
const unsigned type unsigned_type_max = ~(unsigned type)0; 

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

const signed type signed_type_max = (signed type)(unsigned_type_max >> 1); 
const signed type signed_type_min = (signed type)(~(signed_type_max)); 

चल बिन्दु के लिए

, वहाँ 4 सीमा नहीं है, हालांकि केवल सकारात्मक सीमा knowning पर्याप्त है, नकारात्मक सीमा सिर्फ सकारात्मक सीमा उल्टे संकेत हैं। फ्लोटिंग पॉइंट नंबरों का प्रतिनिधित्व करने के लिए कई संभावित तरीके हैं, लेकिन उन लोगों के लिए जो बाइनरी (आधार 10 के बजाए) फ्लोटिंग पॉइंट का उपयोग करते हैं, लगभग हर कोई आईईईई प्रस्तुतियों का उपयोग करता है।

आईईईई फ्लोट्स के लिए, सबसे छोटा सकारात्मक फ़्लोटिंग पॉइंट मान तब होता है जब एक्सपोनेंट का कम बिट 1 होता है और अन्य सभी बिट 0 होते हैं। सबसे बड़ा नकारात्मक फ्लोटिंग पॉइंट वैल्यू इसके विपरीत विपरीत है। हालांकि, एक पूर्णांक प्रकार के बिना जिसे दिए गए फ़्लोटिंग पॉइंट प्रकार के समान आकार के रूप में जाना जाता है, लूप को निष्पादित करने के अलावा इस बिट हेरफेर को करने का कोई तरीका नहीं है। यदि आपके पास एक पूर्णांक प्रकार है जो आप जानते हैं कि आपके फ़्लोटिंग पॉइंट प्रकार के समान आकार है, तो आप इसे एक ही ऑपरेशन के रूप में कर सकते हैं।

const float_type get_float_type_smallest() { 
    const float_type float_1 = (float_type)1.0; 
    const float_type float_2 = (float_type)0.5; 
    union { 
     byte ab[sizeof(float_type)]; 
     float_type fl; 
     } u; 
    for (int ii = 0; ii < 0; ++ii) 
     u.ab[ii] = ((byte*)&float_1)[ii]^((byte*)&float_2)[ii]; 
    return u.fl; 
    } 

const float_type get_float_type_largest() { 
    union { 
     byte ab[sizeof(float_type)]; 
     float_type fl; 
     } u; 
    u.fl = get_float_type_smallest(); 
    for (int ii = 0; ii < 0; ++ii) 
     u.ab[ii] = ~u.ab[ii]; 
    return -u.fl; // Need to re-invert the sign bit. 
    }