जावा और सी # में आदिम प्रकार अलग हैं?

Question

मैं मैन्युअल रूप से जावा से सी # में कोड परिवर्तित कर रहा हूं और (जिसे मैं कॉल करता हूं) के साथ संघर्ष कर रहा हूं (देखें, उदाहरण के लिए Do autoboxing and unboxing behave differently in Java and C#)। उत्तरों से मैं समझता हूं कि double (सी #) और Double (सी #) बराबर हैं और double (सी #) कंटेनर में भी उपयोग किए जा सकते हैं, उदा। एक शब्दकोश में एक कुंजी के रूप में। हालांकि, double (जावा) का उपयोग हैश मैप जैसे कंटेनर में नहीं किया जा सकता है, यही कारण है कि यह Double (जावा) पर ऑटो-बॉक्स किया गया है।

1. double (सी #) एक आदिम या वस्तु है?
2. यदि यह एक प्राचीन है तो यह double (जावा) से अलग तरीके से व्यवहार करता है?

double (सी #) को nullable बनाये जाने तक शून्य पर सेट नहीं किया जा सकता है।

3. double? (सी #) Double (जावा) के बराबर है? क्या वे दोनों वस्तुओं के रूप में संदर्भित हैं?

Answer 1

दोनों सी # और जावा आदिम या) है। "

जावा में के सभी प्रकार के प्राचीन प्रकार (जो जावा में एक छोटा परिमित सेट है) के लिए रैपर क्लास प्रकार हैं जो उन्हें ऑब्जेक्ट के रूप में माना जा सकता है। double/Double, int/Integer, bool/Boolean, आदि। ये रैपर प्रकार संदर्भ-प्रकार हैं (पढ़ें: कक्षाएं) और, जैसे null ऐसे टाइप किए गए अभिव्यक्तियों/चरों को असाइन करने के लिए एक वैध मान है। जावा के हाल के संस्करण (1.5/5 +) प्राइमेटिव्स से उनके संबंधित रैपर तक अंतर्निहित दबाव में जोड़ें। ;, भाग में सी # के माध्यम सेstructures मूल्य प्रकार के एक अनंत सेट का समर्थन करता है, क्योंकि -

// Java 
Boolean b = true; // implicit conversion boolean -> Boolean (Java 5+) 
Boolean b = null; // okay, can assign null to a reference type 
boolean n = null; // WRONG - null is not a boolean! 

सी # एक इस तरह के एक प्रत्यक्ष रैपिंग प्रदान नहीं करता है बल्कि, 0 #रैपर प्रकार की शुरूआत से सी # हैंडल "शून्य मूल्य प्रकार" हैंडल करता है। इसके अलावा जावा की तरह सी #, मूल्य प्रकार T से Nullable<T> से अंतर्निहित रूपांतरण है, इस प्रतिबंध के साथ कि टी "नामुमकिन प्रकार" नहीं है।

// C# 
Nullable<bool> b = true; // implicit conversion bool -> bool? 
bool? b = true;   // short type syntax, implicit conversion 
bool? b = null;   // okay, can assign null as a Nullable-type 
bool b = null;   // WRONG - null is not a bool 

ध्यान दें कि Nullable<T> भी एक मान प्रकार है और इस तरह जब/अगर एक मूल्य के "ढेर पर" है या नहीं करने के लिए मानक संरचना नियमों का पालन करती।

टिप्पणी के जवाब में:

बिल्कुल सही, Nullable एक मूल्य की तरह किया जा रहा है कुछ मामलों में एक अधिक कॉम्पैक्ट स्मृति पदचिह्न के लिए के रूप में यह एक संदर्भ की स्मृति भूमि के ऊपर से बच सकते हैं समर्थ बनाता है, टाइप करें: What is the memory footprint of a Nullable<T>। हालांकि इसे अभी भी गैर-शून्य प्रकार की तुलना में अधिक मेमोरी की आवश्यकता है क्योंकि यह याद रखना है कि मान क्या है, ठीक है, शून्य है या नहीं। संरेखण के मुद्दों और वीएम कार्यान्वयन के आधार पर, यह "पूर्ण" ऑब्जेक्ट से काफी कम हो सकता है या नहीं। इसके अतिरिक्त, क्योंकि सी #/CLR में मानों reified कर रहे हैं, किसी भी उठाने आपरेशन कि किया जाना चाहिए पर विचार करें:

// C# 
object x = null; 
x = (bool?)true; 
(x as bool?).Value // true 

लेख संदर्भ प्रकार स्मृति की खपत के बारे में बात करती है Java Tip 130: Do you know your data size? (जावा में)। ध्यान देने योग्य बात यह है कि JVM में आंतरिक रूप से Arrays के विशेष संस्करण हैं, प्रत्येक आदिम प्रकार और ऑब्जेक्ट्स के लिए एक (हालांकि, कृपया ध्यान दें कि इस आलेख में भ्रामक बयान) शामिल हैं। ध्यान दें कि ऑब्जेक्ट्स (बनाम प्राइमेटिव्स) में अतिरिक्त मेमोरी ओवरहेड और बाइट संरेखण के मुद्दे कैसे होते हैं। सी # हालांकि, Nullable<T> प्रकार बनाम अनुकूलित विशेष-मामलों के लिए अनुकूलित किए गए सरणी मामले को बढ़ा सकता है क्योंकि Nullable<T> स्वयं ही एक संरचना प्रकार (या "आदिम") है।

हालांकि, एक ऑब्जेक्ट, केवल एक परिवर्तनीय स्लॉट में "संदर्भ" बनाए रखने के लिए एक छोटे से निश्चित आकार की आवश्यकता होती है। दूसरी ओर Nullable<LargeStruct> प्रकार का एक वैरिएबल स्लॉट, LargeStruct+Nullable के लिए स्थान होना चाहिए (स्लॉट स्वयं ढेर पर हो सकता है)। C# Concepts: Value vs Reference Types देखें। ध्यान दें कि चर के ऊपर "उठाने" उदाहरण में object: object सी # (संदर्भ प्रकार और मूल्य प्रकार दोनों के माता-पिता) में "मूल प्रकार" है और एक विशिष्ट मान प्रकार नहीं है।

---

सी # भाषा उपनाम आदिम/आम प्रकार है कि 'दोस्ताना लोअरकेस "प्रकार के नाम करने के लिए उपयोग की अनुमति के लिए की एक निश्चित सेट का समर्थन करता है।उदाहरण के लिए, doubleSystem.Double और int के लिए उपनाम System.Int32 के लिए उपनाम है। जब तक कोई अलग Double प्रकार दायरे में आयात नहीं किया जाता है, double और Double उसी प्रकार का संदर्भ C# में संदर्भित करेगा। मैं उपनामों का उपयोग करने की सलाह देता हूं जब तक कि अन्यथा करने का कोई कारण न हो।

Answer 2

Nullable<double> (उर्फ double?) सी # में (शब्द "प्रथम श्रेणी वस्तु" इस चर्चा में उपयोगी? के उपयोग है) नहीं जावा में एक Double के समान है।

से पहले जावा autoboxing/unboxing था, तो आप मैन्युअल पुरातन और प्रथम श्रेणी के वस्तुओं के बीच परिवर्तित करने के लिए किया था:

Double dblObj = new Double(2.0); 
double dblPrim = dblObj.doubleValue(); 

जावा 1.5 में बदल गया है, तो आप सिर्फ कर सकता है:

Double dblObj = 2.0; 
double dblPrim = dblObj; 

और जावा उपरोक्त उदाहरण को स्वचालित रूप से मिरर करने के लिए कोड डालेगा।

सी # अलग है क्योंकि असीमित संख्या "आदिम" प्रकार हैं (सीएलआर value types कहता है)। ये अधिकतर जावा के प्राइमेटिव्स की तरह व्यवहार करते हैं, वैल्यू सेमेन्टिक्स का उपयोग करते हुए। आप struct कीवर्ड का उपयोग कर नए मान प्रकार बना सकते हैं। सी # में सभी मूल्य प्रकारों के लिए ऑटोबॉक्सिंग/अनबॉक्सिंग है, और यह भी सभी मान प्रकार Object से प्राप्त होता है।

तो आप एक मान प्रकार (जैसे double) का उपयोग कर सकते हैं, जहां आप किसी ऑब्जेक्ट संदर्भ का उपयोग करेंगे (उदा। Dictionary में एक कुंजी के रूप में) और यदि आवश्यक हो तो इसे बॉक्स किया जाएगा, या फिर सीधे उपयोग किया जाएगा। (सी # के जेनेरिक्स कार्यान्वयन काफी अच्छा सबसे परिस्थितियों में मुक्केबाजी से बचना है।)

Answer 3

सी # में, का सबसे अच्छा तरीका वस्तुओं रहे हैं अलग करने के लिए "मान प्रकार" जो पुरातन की तरह थोड़े हैं द्वारा - int रों, bool रों, आदि और "संदर्भ , पूर्णांक, डबल, नाव, आदि ...

हालांकि इस सी # और जावा विभाजित करने के लिए करते हैं के बाद: - प्रकार "(मूल्य" प्रकार कक्षाओं आदि