जावा अहस्ताक्षरित ints का समर्थन क्यों नहीं करता है?

Question

जावा में अहस्ताक्षरित पूर्णांकों के लिए समर्थन शामिल क्यों नहीं है?

यह मुझे एक अजीब चूक लगता है, यह देखते हुए कि वे एक कोड लिखने की अनुमति देते हैं जो अप्रत्याशित बड़े इनपुट पर ओवरफ्लो का उत्पादन करने की कम संभावना है।

इसके अलावा, अहस्ताक्षरित पूर्णांक का उपयोग करना स्वयं-प्रलेखन का एक रूप हो सकता है, क्योंकि वे संकेत करते हैं कि अहस्ताक्षरित इंट को धारण करने का इरादा कभी भी नकारात्मक नहीं होना चाहिए।

अंत में, कुछ मामलों में, अहस्ताक्षरित पूर्णांक कुछ परिचालन के लिए अधिक कुशल हो सकते हैं, जैसे कि विभाजन।

इन्हें शामिल करने के लिए क्या नकारात्मक पहलू है?

Comments

मुझे नहीं पता, लेकिन यह मुझे नरक से बाहर निकालता है; उदाहरण के लिए इस तरह नेटवर्क कोड लिखना बहुत कठिन है।

— तमस Czinege

काश भाषा / डेटाबेस / ... दुनिया: संख्या और स्ट्रिंग :) में केवल दो प्रकार होते हैं

— लियाओ

नेटवर्क कोड लिखना ज्यादा कठिन नहीं है। BTW InputStream.read (), एक अहस्ताक्षरित बाइट लौटाता है, उदाहरण के लिए एक हस्ताक्षरित नहीं है, इसलिए नेटवर्क उदाहरण एक भ्रम की स्थिति है। इसका केवल यह भ्रम है कि आप मान रहे हैं कि हस्ताक्षरित मूल्य लिखना किसी अहस्ताक्षरित को लिखने के लिए अलग है। यदि आप वास्तव में बाइट स्तर पर क्या हो रहा है पता नहीं है।

— पीटर लॉरी

@ZachSaw - जब मैंने एक भाषा डिजाइनर को वह बोली बनाते देखा तो मैंने भी डबल-लिया। एक अहस्ताक्षरित पूर्णांक से सरल कुछ भी नहीं है। हस्ताक्षर किए गए पूर्णांक जटिल हैं। विशेष रूप से जब आप ट्रांजिस्टर स्तर पर बिट ट्विडलिंग पर विचार करते हैं। और एक हस्ताक्षरित पूर्णांक कैसे बदलता है? मुझे यह निष्कर्ष निकालना था कि जावा के डिजाइनर के पास बूलियन लॉजिक को समझने का एक गंभीर मुद्दा है।

— पीपी।

मेरे लिए यह आसान हो जाता है कि किसी भी इमेज प्रोसेसिंग को इमेजेस के साथ byteएक सीधा 140ग्रे लेवल नहीं दिया जा सकता है लेकिन -116आपको & 0xffसही वैल्यू प्राप्त करने की आवश्यकता है ।

— मैथ्यू

Answer 1

यह सरलता के बारे में, गोस्लिंग और अन्य लोगों के साथ एक साक्षात्कार से है :

गोसलिंग: मेरे लिए एक भाषा डिजाइनर के रूप में, जिसे मैं वास्तव में इन दिनों खुद के रूप में नहीं गिनता हूं, जो "सरल" वास्तव में समाप्त हो गया है, मैं उम्मीद कर सकता था कि मैं जे। रैंडम डेवलपर को उसके सिर में धारण करने की उम्मीद कर सकता हूं। यह परिभाषा कहती है कि, उदाहरण के लिए, जावा नहीं है - और वास्तव में इन भाषाओं का एक बहुत कोने के मामलों के साथ समाप्त होता है, ऐसी चीजें जो वास्तव में कोई नहीं समझता है। अहस्ताक्षरित के बारे में किसी भी सी डेवलपर को क्विज़ करें, और बहुत जल्द आपको पता चलता है कि लगभग कोई भी सी डेवलपर्स वास्तव में यह नहीं समझता है कि अहस्ताक्षरित के साथ क्या होता है। जैसी चीजें सी कॉम्प्लेक्स बनीं। जावा का भाषा हिस्सा है, मुझे लगता है, बहुत आसान है। पुस्तकालयों को आपको देखना होगा।

Comments

मैं यहाँ एक विशिष्ट उदाहरण (CLR से कम नहीं) के साथ गोस्लिंग से असहमत होने जा रहा हूँ। एक ऐरे को एक हस्ताक्षरित पूर्णांक लंबाई मान या एक अहस्ताक्षरित लंबाई देने में और अधिक भ्रामक क्या है? एक ऐरे के लिए ऋणात्मक लंबाई होना असंभव है फिर भी हमारे एपीआई से संकेत मिलता है।

— जारेदपार

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

— Uri

अगर जावा को अहस्ताक्षरित पूर्णांक की आवश्यकता है क्योंकि सरणी सूचक नकारात्मक नहीं हो सकते हैं, तो उसे सबरेंज (एक ला पास्कल) की भी आवश्यकता है क्योंकि एक सरणी सूचकांक सरणी आकार से अधिक नहीं हो सकता है।

— वेन कॉनरैड

ठीक है, उन्होंने सिर्फ अहस्ताक्षरित प्रकार न होने के फायदे बताए। अब नुकसान के बारे में गिनते हैं ...

— मोशे रेव

मुझे भाषा की सरलता पर कोड सादगी पसंद है। इसलिए मुझे जावा से नफरत है।

— पीजूसन

Answer 2

लाइनों के बीच में पढ़ने, मुझे लगता है कि तर्क कुछ इस तरह था:

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

अधिकतर, मैं कहूंगा कि यह एक उचित निर्णय था। संभवतः, मेरे पास होगा:

• बाइट को अहस्ताक्षरित, या कम से कम एक हस्ताक्षरित / अहस्ताक्षरित विकल्प प्रदान किया है, संभवतः विभिन्न नामों के साथ, इस एक डेटा प्रकार के लिए (इसे हस्ताक्षरित करना स्थिरता के लिए अच्छा है, लेकिन आपको कभी हस्ताक्षरित बाइट की आवश्यकता है?)
• 'लघु' के साथ दूर किया (जब आपने अंतिम बार 16-बिट हस्ताक्षरित अंकगणित का उपयोग किया था?)

फिर भी, थोड़े से कल्गिंग के साथ, 32 बिट्स तक के अहस्ताक्षरित मानों पर संचालन बहुत बुरा नहीं है, और अधिकांश लोगों को 64-बिट डिवीजन या तुलना की आवश्यकता नहीं है।

Comments

मुझे अहस्ताक्षरित बाइट्स भी पसंद हैं, लेकिन मुझे पूर्णतया निरंतरता के लाभ पर संदेह है कि बिना बाइट्स की सुविधा के पूर्णांक आउटवेब्स में परिवर्तन होगा।

— एलन मूर

"रोजमर्रा के उद्देश्यों के लिए, उन्हें लगा कि हस्ताक्षरित डेटा प्रकारों के लिए सबसे आम जरूरत थी"। मेरे C ++ कोड में, मैं अक्सर खुद को यह सोचकर ढूंढता हूं कि "पृथ्वी पर मैं एक अहस्ताक्षरित के बजाय यहां एक हस्ताक्षरित पूर्णांक का उपयोग क्यों कर रहा हूं?"। मुझे लगता है कि नियम के बजाय "हस्ताक्षरित" अपवाद है (बेशक, यह डोमेन पर निर्भर करता है, लेकिन एक कारण है कि सकारात्मक पूर्णांक को प्राकृतिक संख्या कहा जाता है ;-))।

— ल्यूक टॉरिल

अहस्ताक्षरित बाइट्स के लिए कॉल करने के लिए, इमेज प्रोसेसिंग करते समय, बाइट्स को अहस्ताक्षरित मान लें (जैसा कि यह होना चाहिए), मुझे घंटों डिबगिंग में बिताया।

— हेलिन वांग

आपको आश्चर्य होता है कि कितनी बार shortउपयोग किया जाता है - डीफ़्लैट / गज़िप / इनफ्लो एल्गोरिदम 16 बिट है और वे शॉर्ट्स पर बहुत अधिक भरोसा करते हैं ... या कम से कम short[][माना जाता है कि वे देशी हैं - फिर भी एल्गोरिथ्म का जावा इवा डेटा के टेराबीट्स को ले जाता है]। उत्तरार्द्ध ( short[]) का महत्वपूर्ण लाभ है int[]क्योंकि इसमें दो बार कम मेमोरी और कम मेमोरी = बेहतर कैशिंग गुण, बहुत बेहतर प्रदर्शन होता है।

— bestsss

हालांकि किसी विशेष एप्लिकेशन में, आपको यह मापना चाहिए कि क्या शॉर्ट्स का उपयोग करने से आपको इसे सही मानने के बजाय बेहतर प्रदर्शन मिलता है। यह संभव है कि अतिरिक्त जिगरी-पोकरी को चींटियों के बजाय शॉर्ट्स में हेरफेर करने की आवश्यकता होती है (जो आमतौर पर प्रकार है कि प्रोसेसर 'उपयोग करना पसंद करता है') वास्तव में एक विशेष अनुप्रयोग में प्रदर्शन के लिए हानिकारक हो सकता है। हमेशा नहीं, लेकिन आपको परीक्षण करना चाहिए, मान नहीं।

— नील कॉफ़ी

Answer 3

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

byte - 8-बिट हस्ताक्षरित पूर्णांक

short - 16-बिट हस्ताक्षरित पूर्णांक

int - 32-बिट हस्ताक्षरित पूर्णांक

long - 64-बिट हस्ताक्षरित पूर्णांक

char - 16-बिट चरित्र (अहस्ताक्षरित पूर्णांक)

यद्यपि अंकगणित का charसमर्थन नहीं करता है unsigned, लेकिन इसे अनिवार्य रूप से unsignedपूर्णांक माना जा सकता है । आपको अंकगणित संचालन को स्पष्ट रूप से डालना होगा char, लेकिन यह आपको unsignedसंख्याएँ निर्दिष्ट करने का एक तरीका प्रदान करता है ।

char a = 0;
char b = 6;
a += 1;
a = (char) (a * b);
a = (char) (a + b);
a = (char) (a - 16);
b = (char) (b % 3);
b = (char) (b / a);
//a = -1; // Generates complier error, must be cast to char
System.out.println(a); // Prints ? 
System.out.println((int) a); // Prints 65532
System.out.println((short) a); // Prints -4
short c = -4;
System.out.println((int) c); // Prints -4, notice the difference with char
a *= 2;
a -= 6;
a /= 3;
a %= 7;
a++;
a--;

हां, अहस्ताक्षरित पूर्णांकों के लिए प्रत्यक्ष समर्थन नहीं है (जाहिर है, मुझे अपने अधिकांश ऑपरेशन चार में वापस करने होंगे यदि प्रत्यक्ष समर्थन नहीं था)। हालांकि, निश्चित रूप से एक अहस्ताक्षरित आदिम डेटा प्रकार मौजूद है। मैं एक अहस्ताक्षरित बाइट को भी देखना पसंद करूंगा, लेकिन मुझे लगता है कि मेमोरी की लागत दोगुनी है और इसके बजाय चार का उपयोग एक व्यवहार्य विकल्प है।

---

संपादित करें

JDK8 के साथ नए APIs हैं Longऔर Integerजो उपचार करते समय सहायक विधि प्रदान करते हैं longऔर intमानों को अहस्ताक्षरित मान के रूप में प्रदान करते हैं।

• compareUnsigned
• divideUnsigned
• parseUnsignedInt
• parseUnsignedLong
• remainderUnsigned
• toUnsignedLong
• toUnsignedString

इसके अतिरिक्त, अमरूद पूर्णांक प्रकारों के लिए समान कार्य करने के लिए कई सहायक विधियां प्रदान करता है जो पूर्णांकों के लिए मूल समर्थन की कमी के द्वारा छोड़े गए अंतर को बंद करने में मदद करता है unsigned।

Comments

लेकिन, उदाहरण के लिए, अंकगणित charका समर्थन करने के लिए बहुत छोटा है long।

यह जावा का एक नुकसान हो सकता है

उम्मीद है कि वे बाइट्स के लिए अनसाइन्टेड वैल्यूज़ का समर्थन करते हैं। चीजों को और आसान बनाता है।

— मिश्रणज

Answer 4

जावा में अहस्ताक्षरित प्रकार हैं, या कम से कम एक: चार एक अहस्ताक्षरित छोटा है। तो जो भी बहाना गोसलिंग फेंकता है वह वास्तव में सिर्फ उसका अज्ञान है कि कोई अन्य अहस्ताक्षरित प्रकार क्यों नहीं हैं।

इसके अलावा लघु प्रकार: शॉर्ट्स का उपयोग हर समय मल्टीमीडिया के लिए किया जाता है। कारण यह है कि आप एक 32-बिट अहस्ताक्षरित लंबे समय में 2 नमूने फिट कर सकते हैं और कई ऑपरेशनों को वेक्टर कर सकते हैं। 8-बिट डेटा और अहस्ताक्षरित बाइट के साथ एक ही बात। आप वेक्टर के लिए एक रजिस्टर में 4 या 8 नमूने फिट कर सकते हैं।

Comments

हाँ, मुझे यकीन है कि आपकी तुलना में गोसलिंग जावा के बारे में बहुत अनभिज्ञ है।

— जेकबॉकर

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

— सुपरकैट

यह charकुछ भी लेकिन पात्रों के लिए उपयोग करने के लिए खराब शैली है ।

— Starblue

@starblue बेशक यह है, लेकिन यह भाषा की एक सीमा के आसपास पाने के लिए एक हैक है

— बेसिक

Answer 5

जैसे ही हस्ताक्षर किए और अहस्ताक्षरित ints एक अभिव्यक्ति बातें गंदा पाने के लिए शुरू में मिलाया जाता है और आप शायद होगा जानकारी खो देते हैं। जावा को साइन इन करने के लिए प्रतिबंधित करने से वास्तव में चीजें साफ हो जाती हैं। मुझे खुशी है कि मुझे पूरे हस्ताक्षरित / अहस्ताक्षरित व्यवसाय के बारे में चिंता करने की ज़रूरत नहीं है, हालांकि मैं कभी-कभी एक बाइट में 8 वीं बिट को याद करता हूं।

Comments

हस्ताक्षरित / अहस्ताक्षरित मिश्रण के रूप में: आपके पास अहस्ताक्षरित प्रकार हो सकते हैं, लेकिन मिश्रण को अस्वीकार कर सकते हैं (या स्पष्ट जातियों की आवश्यकता होती है)। फिर भी, यह स्पष्ट नहीं है कि क्या यह आवश्यक है।

— साल्स्के

C ++ में आपको static_castइन्हें मिलाने के लिए लगभग चारों ओर s छिड़कना होगा। यह वास्तव में गड़बड़ है।

— Raedwald

8 बिट वहाँ है, यह सिर्फ संकेत के रूप में खुद को छिपाने की कोशिश करता है।

— Starblue

चीजें केवल 32 बिट या बड़े प्रकार के साथ गड़बड़ हो जाती हैं। मुझे लगता है कि कोई कारण नहीं है कि जावा को byteहस्ताक्षर नहीं करना चाहिए था क्योंकि यह पास्कल था।

— 22

जब आप जावा में छवि प्रसंस्करण के साथ समस्या कर रहे हों, तो मुझे देखें, जहां आप बाइट्स को निरस्त किए जाने की अपेक्षा करते हैं। तब आपको पता चलेगा कि & 0xFF'प्रत्येक बाइट-टू-इंट प्रमोशन कोड कोड को और भी अधिक गड़बड़ कर देता है।

— बिट

Answer 6

http://skeletoncoder.blogspot.com/2006/09/java-tutorials-why-no-unsigned.html

इस आदमी का कहना है क्योंकि सी मानक के संचालन को परिभाषित करता है जिसमें अहस्ताक्षरित और हस्ताक्षर किए गए किलों को अहस्ताक्षरित माना जाता है। यह नकारात्मक हस्ताक्षरित पूर्णांक को एक बड़े अहस्ताक्षरित int में घूमने के लिए संभावित रूप से बग पैदा कर सकता है।

Comments

जावा ने पूर्णांक रोल पर भी हस्ताक्षर किए। मैं तुम्हारी बात नहीं देखता।

— फू

@foo: हस्ताक्षर किए गए पूर्णांकों को समस्याएँ पैदा करने से पहले बड़ा होना पड़ता है। इसके विपरीत, सी में, किसी को किसी भी नकारात्मक पूर्णांक की तुलना में समस्याएं हो सकती हैं - यहां तक ​​कि -1किसी भी अहस्ताक्षरित quanity - शून्य भी।

— सुपरकैट

यह बहुत बुरा है जावा में अहस्ताक्षरित प्रकार शामिल नहीं हो सकते हैं, लेकिन एक सीमित सेट के साथ रूपांतरण और मिश्रित ऑपरेटर (कुछ इस तरह से अनुरूप हैं कि सी में एक पॉइंटर में 5 जोड़ सकते हैं, लेकिन एक पॉइंटर की तुलना 5 से नहीं कर सकता है) । एक अंतर्निहित कास्ट होने पर मिश्रित प्रकार पर एक ऑपरेटर का उपयोग करने वाला विचार, उस कास्ट के निहित उपयोग को मजबूर करना चाहिए (और परिणाम प्रकार के रूप में उपयोग करें) दोनों .NET में बहुत सारे संदिग्ध डिजाइन निर्णयों के दिल में स्थित है। जावा।

— सुपरकट

अपने उत्तर पर शेख़ी नहीं, लेकिन -1"अज्ञात" उम्र (जैसा कि लेख बताता है) "कोड गंध" के क्लासिक उदाहरणों में से एक है । उदाहरण के लिए, यदि आप यह गणना करना चाहते हैं कि "ऐलिस बॉब की तुलना में कितनी बड़ी है?", और ए = 25 और बी = -1, तो आपको इसका उत्तर मिलेगा ±26जो कि गलत है। अज्ञात मानों की उचित हैंडलिंग किसी प्रकार की होती है Option<TArg>जब Some(25) - Noneवे वापस लौटते हैं None।

— बाइटबस्टर

Answer 7

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

व्यावहारिक सलाह के लिए:

• यदि आपके मूल्य कुछ हद तक मनमाने आकार के हैं और intउपयोग में नहीं आते हैं long। यदि वे longउपयोग में नहीं आते हैं BigInteger।

• जब आप अंतरिक्ष को बचाने की आवश्यकता होती है, तो केवल सरणियों के लिए छोटे प्रकारों का उपयोग करें।

• यदि आपको वास्तव में 64/32/16/8 बिट्स की आवश्यकता है, तो डिवीजन, तुलना, राइट शिफ्ट और कास्टिंग को छोड़कर, साइन / / की चिंता करना बंद करें long/ int/ का उपयोग करें ।shortbyte

"सी से जावा में एक यादृच्छिक संख्या जनरेटर को पोर्ट करना" के बारे में यह उत्तर भी देखें ।

Comments

हाँ, सही स्थानांतरण के लिए आप के बीच चयन करने के लिए है >>और >>>हस्ताक्षर किए और अहस्ताक्षरित, क्रमशः के लिए। छोड़ दिया स्थानांतरण कोई समस्या नहीं है।

— Starblue

@starblue वास्तव में और के >>>लिए काम नहीं करता है । उदाहरण के लिए, पैदावार के बजाय । एक और उदाहरण: परिणाम में होगा । बेशक आप कर सकते हैं लेकिन यह एक और ऑपरेशन (बिटवाइज़ और) जोड़ता है। shortbyte(byte)0xff>>>10x7fffffff0x7fbyte b=(byte)0xff; b>>>=1;b==(byte)0xffb=(byte)(b & 0xff >> 1);

— 21-05 पर CITBL

"... यहां तक ​​कि सरलीकृत मॉडल के साथ अधिकांश जावा प्रोग्रामर यह नहीं जानते हैं कि बुनियादी संख्यात्मक प्रकार कैसे व्यवहार करते हैं ..." मेरे अंदर कुछ ऐसी भाषा है जो सबसे सामान्य सामान्य भाजक के उद्देश्य से बनाई गई भाषा है।

— बेसिक

आपके उत्तर में प्रारंभिक लाइन, अधिक जटिलता और थोड़ा लाभ के बारे में, ठीक वही है जो मैंने अपने लेख में 6 साल बाद विस्तार से बताया है: nayuki.io/page/unsigned-int-considered-harmful-for-java

— Nayuki

@Nayuki आपका लेख वास्तव में अच्छा है। केवल एक छोटी सी टिप्पणी, मैं XOR के बजाय तुलना ऑपरेटरों के लिए 0x80000000 के अतिरिक्त का उपयोग करूंगा, क्योंकि यह बताता है कि यह क्यों काम करता है, यह सन्निहित क्षेत्र को स्थानांतरित करता है जहां तुलना -MAXINT से 0. तक होती है। इसका प्रभाव बिल्कुल समान है।

— Starblue

Answer 8

JDK8 के साथ यह उनके लिए कुछ समर्थन करता है।

हम अभी तक गोस्लिंग की चिंताओं के बावजूद जावा में अहस्ताक्षरित प्रकारों का पूर्ण समर्थन देख सकते हैं।

Comments

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

— बेसिक

Answer 9

मुझे पता है कि यह पोस्ट बहुत पुरानी है; हालांकि आपकी रुचि के लिए, जावा 8 और बाद में, आप intएक 32-बिट पूर्णांक का प्रतिनिधित्व करने के लिए डेटा प्रकार का उपयोग कर सकते हैं , जिसका न्यूनतम मान 0 और अधिकतम 2 ³² .1 है। अहस्ताक्षरित पूर्णांक और स्थिर विधियों जैसे डेटा प्रकार Integerका उपयोग करने के लिए वर्ग का उपयोग करें , आदि को अहस्ताक्षरित पूर्णांक के लिए अंकगणितीय कार्यों का समर्थन करने के लिए वर्ग में जोड़ा गया है ।intcompareUnsigned()divideUnsigned()Integer

Answer 10

मैंने कहानियाँ सुनी हैं कि उन्हें ओरिजिनल जावा रिलीज़ के करीब शामिल किया जाना था। ओक जावा के अग्रदूत थे, और कुछ विशेष दस्तावेजों में उपयोग किए गए मूल्यों का उल्लेख था। दुर्भाग्य से ये जावा भाषा में कभी नहीं बने। जहां तक ​​किसी को यह पता लगाने में सक्षम है कि वे अभी लागू नहीं हुए हैं, समय की कमी के कारण।

Comments

यह ठीक होगा ... गोसलिंग साक्षात्कार से सबूतों का मतलब है कि अहस्ताक्षरित पूर्णांक (इसके अलावा char) बाहर छोड़ दिए गए थे क्योंकि डिजाइनरों ने सोचा था कि वे एक बुरा विचार थे ... भाषा के लक्ष्यों को देखते हुए।

— स्टीफन सी

यह एक अच्छा विचार है कि चश्मदीद गवाह बयानों में बहुत अधिक मूल्य न रखें, अगर दस्तावेजी सबूत भी हाथ में हैं।

— user7610

Answer 11

मैंने एक बार C ++ मानक समिति के किसी व्यक्ति के साथ C ++ पाठ्यक्रम लिया था जिसने यह अनुमान लगाया था कि जावा ने अहस्ताक्षरित पूर्णांकों से बचने के लिए सही निर्णय लिया है क्योंकि (1) अधिकांश प्रोग्राम जो अहस्ताक्षरित पूर्णांक का उपयोग करते हैं वे हस्ताक्षर किए पूर्णांक के साथ भी कर सकते हैं और यह अधिक स्वाभाविक है लोग कैसे सोचते हैं, और (2) अहस्ताक्षरित पूर्णांक का उपयोग करने से परिणाम बहुत आसान हो जाता है लेकिन हस्ताक्षरित और अहस्ताक्षरित प्रकारों के बीच परिवर्तित होने पर पूर्णांक अंकगणितीय अतिप्रवाह और महत्वपूर्ण बिट्स खोने जैसे मुद्दों को डीबग करना मुश्किल होता है। यदि आप गलती से हस्ताक्षरित पूर्णांक का उपयोग करके 0 से 1 घटाते हैं तो यह अक्सर आपके प्रोग्राम को क्रैश करने का कारण बनता है और बग को खोजने के लिए आसान बनाता है यदि यह 2 ^ 32 - 1 के आसपास लपेटता है, और संकलक और स्थैतिक विश्लेषण उपकरण और रनटाइम चेक को देखना होगा मान लें कि आप जानते हैं कि आप क्या कर रहे हैं क्योंकि आपने अहस्ताक्षरित अंकगणित का उपयोग करना चुना है। इसके अलावा,

बहुत पहले, जब मेमोरी सीमित थी और प्रोसेसर एक बार में 64 बिट्स पर स्वचालित रूप से काम नहीं करते थे, तो हर बिट बहुत अधिक गिना जाता था, इसलिए हस्ताक्षरित बनाम बाइट्स या शॉर्ट्स वास्तव में बहुत अधिक बार मायने रखते थे और स्पष्ट रूप से सही डिजाइन निर्णय था। आज सिर्फ एक हस्ताक्षरित इंट का उपयोग करना लगभग सभी नियमित प्रोग्रामिंग मामलों में पर्याप्त से अधिक है, और यदि आपके कार्यक्रम को वास्तव में 2 ^ 31 - 1 से बड़े मूल्यों का उपयोग करने की आवश्यकता है, तो आप अक्सर बस वैसे भी एक लंबा चाहते हैं। एक बार जब आप लोंगो का उपयोग करने के क्षेत्र में हो जाते हैं, तो यह एक कारण है कि आप वास्तव में 2 ^ 63 - 1 पॉजिटिव पूर्णांकों के साथ प्राप्त नहीं कर सकते हैं। जब भी हम 128 बिट प्रोसेसर पर जाते हैं तो यह एक समस्या से भी कम होगा।

Answer 12

आपका सवाल है कि "जावा अहस्ताक्षरित समर्थन का समर्थन क्यों नहीं करता है"?

: और अपने प्रश्न का मेरा उत्तर जावा चाहता है कि यह के सभी आदिम प्रकार है बाइट , चार , लघु , पूर्णांक और लंबे समय तक के रूप में व्यवहार किया जाना चाहिए बाइट , शब्द , DWORD और QWORD क्रमशः, वास्तव में विधानसभा में की तरह, और जावा ऑपरेटरों रहे हैं पर हस्ताक्षर किए चार को छोड़कर अन्य सभी प्रकार के संचालन आदिम प्रकार के होते हैं , लेकिन केवल चार पर ही उन्हें केवल 16 बिट का अहस्ताक्षरित किया जाता है।

तो माना जाता है कि स्थिर तरीके 32 और 64 बिट दोनों के लिए भी अहस्ताक्षरित संचालन हैं ।

आपको अंतिम वर्ग की आवश्यकता है, जिसके स्थिर तरीकों को अहस्ताक्षरित संचालन के लिए बुलाया जा सकता है ।

आप इस अंतिम वर्ग को बना सकते हैं, इसे जो चाहें नाम से पुकार सकते हैं और इसे स्थैतिक तरीकों से लागू कर सकते हैं।

यदि आपके पास स्थैतिक तरीकों को लागू करने के तरीके के बारे में कोई जानकारी नहीं है, तो यह लिंक आपकी मदद कर सकता है।

मेरी राय में, जावा है नहीं C ++ के समान सब पर है, अगर यह न अहस्ताक्षरित प्रकार का समर्थन है और न ही ऑपरेटर ओवरलोडिंग, इसलिए मुझे लगता है कि जावा दोनों सी ++ से और सी से पूरी तरह अलग भाषा के रूप में व्यवहार किया जाना चाहिए

यह भाषाओं के नाम से भी पूरी तरह से अलग है।

इसलिए मैं जावा को C के समान कोड टाइप करने की सलाह नहीं देता और मैं C ++ के समान कोड टाइप करने की सलाह नहीं देता, क्योंकि तब जावा में आप वह नहीं कर पाएंगे जो आप C ++ में करना चाहते हैं। यानी कोड C ++ की तरह जारी नहीं रहेगा और मेरे लिए यह कोड की तरह खराब है, बीच में स्टाइल बदलने के लिए।

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

इसके अलावा, मैं का उपयोग कर से बचने के लिए सलाह देते हैं कम , पूर्णांक और लंबे आदिम प्रकार, और उपयोग शब्द , DWORD और QWORD बजाय क्रमशः, और आप के बजाय अहस्ताक्षरित के संचालन के लिए स्थिर तरीकों कॉल कर रहे हैं के बारे में और / या हस्ताक्षर किए आपरेशन ऑपरेटरों का उपयोग कर की।

आप केवल हस्ताक्षर किए संचालन करते हैं और केवल कोड में ऑपरेटरों का उपयोग करने के बारे में हैं, तो यह इन आदिम प्रकार का उपयोग करना उचित है कम , पूर्णांक और लंबे समय तक ।

असल में शब्द , DWORD और QWORD करते नहीं भाषा में मौजूद हैं, लेकिन आप प्रत्येक के लिए नया वर्ग बना सकते हैं और प्रत्येक के कार्यान्वयन बहुत आसान होना चाहिए:

वर्ग शब्द आदिम प्रकार रखती कम ही, वर्ग DWORD आदिम प्रकार रखती है पूर्णांक केवल और वर्ग QWORD आदिम प्रकार धारण लंबे केवल। अब सभी अहस्ताक्षरित और हस्ताक्षर किए गए तरीके स्थिर या आपकी पसंद के अनुसार नहीं, आप प्रत्येक कक्षा में लागू कर सकते हैं, अर्थात सभी 16 बिट संचालन दोनों अहस्ताक्षरित हैं और शब्द वर्ग पर अर्थ नाम देकर हस्ताक्षर किए हैं , सभी 32 बिट संचालन दोनों अहस्ताक्षरित और पर अर्थ नाम देकर हस्ताक्षर किए DWORD वर्ग और सभी 64 बिट आपरेशन दोनों अहस्ताक्षरित और पर अर्थ नाम देकर हस्ताक्षर किए QWORD वर्ग।

यदि आप प्रत्येक विधि के लिए बहुत अधिक अलग-अलग नाम देना पसंद नहीं करते हैं, तो आप हमेशा जावा में ओवरलोडिंग का उपयोग कर सकते हैं, यह पढ़ने के लिए अच्छा है कि जावा ने उसे भी नहीं हटाया है!

यदि आप 8 बिट हस्ताक्षरित संचालन के लिए ऑपरेटरों के बजाय विधियाँ चाहते हैं और 8 बिट अहस्ताक्षरित संचालन के लिए तरीके जिनके पास कोई ऑपरेटर नहीं है, तो आप बाइट क्लास बना सकते हैं (ध्यान दें कि पहला अक्षर 'B' पूँजी है, इसलिए यह नहीं है आदिम प्रकार बाइट ) और इस वर्ग में विधियों को लागू करते हैं।

मूल्य से गुजरने और संदर्भ से गुजरने के बारे में:

अगर मैं गलत नहीं हूँ, सी # में की तरह, आदिम वस्तुओं मूल्य द्वारा पारित कर रहे हैं स्वाभाविक रूप से, लेकिन वर्ग वस्तुओं स्वाभाविक रूप से संदर्भ द्वारा पारित कर रहे हैं, तो इसका मतलब है कि प्रकार के ऑब्जेक्ट बाइट , शब्द , DWORD और QWORD मूल्य द्वारा संदर्भ द्वारा पारित हो जाएगा और नहीं डिफ़ॉल्ट रूप से। काश जावा था struct वस्तुओं के रूप में सी # है, तो सभी बाइट , शब्द , DWORD और QWORD होने के लिए लागू किया जा सकता struct के बजाय वर्ग, इसलिए डिफ़ॉल्ट रूप से वे मूल्य द्वारा पारित किए गए थे और डिफ़ॉल्ट रूप से संदर्भ द्वारा नहीं, जैसे C # में कोई भी संरचनात्मक वस्तु, जैसे कि आदिम प्रकार, मान द्वारा पारित किए जाते हैं और डिफ़ॉल्ट रूप से संदर्भ द्वारा नहीं, लेकिन क्योंकि जावा C # से भी बदतर है और हमारे पास है उससे निपटने के लिए, तब केवल कक्षाएं और इंटरफेस होते हैं, जिन्हें संदर्भ द्वारा पारित किया जाता है और डिफ़ॉल्ट रूप से मूल्य द्वारा नहीं। तो अगर आप पास करना चाहते हैं बाइट , शब्द , DWORD और QWORD , मूल्य से और नहीं वस्तुओं संदर्भ द्वारा जावा में है और यह भी सी # में किसी भी अन्य वर्ग वस्तु की तरह, आप के लिए बस प्रतिलिपि निर्माता का उपयोग करना होगा और बस इतना ही।

यही एकमात्र उपाय है जिसके बारे में मैं सोच सकता हूं। मैं केवल यह चाहता हूं कि मैं शब्द, डॉर्ड और qword के लिए आदिम प्रकार टाइप कर सकता हूं, लेकिन जावा न तो टाइप किए गए समर्थन का उपयोग कर रहा है और न ही सी # का उपयोग करने वाले सी # के विपरीत , जो कि सी के टाइप्डिफ के बराबर है।

उत्पादन के बारे में:

बिट्स के समान अनुक्रम के लिए , आप उन्हें कई तरीकों से प्रिंट कर सकते हैं: बाइनरी के रूप में, दशमलव के रूप में (सी प्रिंटफ में% u का अर्थ), अष्टक के रूप में (जैसे सी प्रिंटफ में% o का अर्थ है), हेक्साडेसिमल के रूप में (जैसे C प्रिन्ट में% x का अर्थ) और पूर्णांक के रूप में (जैसे सी प्रिन्ट में% d का अर्थ)।

ध्यान दें कि सी प्रिंटफ फ़ंक्शन के मापदंडों के रूप में पारित होने वाले चर के प्रकार को नहीं जानता है, इसलिए प्रिंटफ़ प्रत्येक चर के प्रकार को केवल फ़ंक्शन के पहले पैरामीटर को दिए गए चार * ऑब्जेक्ट से जानता है।

तो कक्षाओं में से प्रत्येक में: बाइट , शब्द , DWORD और QWORD , आप प्रिंट विधि लागू कर सकते हैं और printf की कार्यक्षमता प्राप्त है, भले ही वर्ग के आदिम प्रकार पर हस्ताक्षर किए है, तो आप अभी भी यह अहस्ताक्षरित के रूप में कुछ को शामिल कलन विधि का पालन करके प्रिंट कर सकते हैं तार्किक और शिफ्ट ऑपरेशन को अंक प्रिंट करने के लिए आउटपुट प्राप्त करने के लिए।

दुर्भाग्यवश जो लिंक मैंने आपको दिया है वह इन प्रिंट विधियों को लागू करने का तरीका नहीं दिखाता है, लेकिन मुझे यकीन है कि आप उन एल्गोरिदम के लिए Google कर सकते हैं जिन्हें आपको इन प्रिंट विधियों को लागू करने की आवश्यकता है।

यह सब मैं आपके प्रश्न का उत्तर दे सकता हूं और आपको सुझाव दूंगा।

Comments

MASM (Microsoft कोडांतरक) और Windows BYTE, WORD, DWORD, QWORD को अहस्ताक्षरित प्रकारों के रूप में परिभाषित करते हैं। MASM, SBYTE, SWORD, SDWORD, SQWORD के लिए हस्ताक्षरित प्रकार हैं।

— rcgldr

Answer 13

क्योंकि unsignedप्रकार शुद्ध बुराई है।

तथ्य यह है कि सी में unsigned - intउत्पादन unsignedऔर भी अधिक बुराई है।

यहाँ समस्या का एक स्नैपशॉट है जिसने मुझे एक से अधिक बार जलाया:

// We have odd positive number of rays, 
// consecutive ones at angle delta from each other.
assert( rays.size() > 0 && rays.size() % 2 == 1 );

// Get a set of ray at delta angle between them.
for( size_t n = 0; n < rays.size(); ++n )
{
    // Compute the angle between nth ray and the middle one.
    // The index of the middle one is (rays.size() - 1) / 2,
    // the rays are evenly spaced at angle delta, therefore
    // the magnitude of the angle between nth ray and the 
    // middle one is: 
    double angle = delta * fabs( n - (rays.size() - 1) / 2 ); 

    // Do something else ...
}

क्या आपने अभी तक बग पर ध्यान दिया है? मैं स्वीकार करता हूं कि मैंने केवल डिबगर के साथ कदम रखने के बाद इसे देखा था।

क्योंकि nअहस्ताक्षरित प्रकार size_tपूरी अभिव्यक्ति का n - (rays.size() - 1) / 2मूल्यांकन करता है unsigned। उस एक्सप्रेशन का अर्थ है कि मध्य से वें किरण की एक हस्ताक्षरित स्थिति n: बाईं ओर मध्य से पहली किरण की स्थिति -1 होगी, दाईं ओर की 1 की स्थिति +1 होगी, आदि के बाद एब्स वैल्यू लेना और deltaकोण से गुणा करना, मुझे nवें कोण और मध्य के बीच का कोण मिलेगा ।

दुर्भाग्य से मेरे लिए उपरोक्त अभिव्यक्ति में बुराई अहस्ताक्षरित थी और कहने के लिए मूल्यांकन करने के बजाय, -1, यह 2 ^ 32-1 का मूल्यांकन करता था। doubleबग को सील करने के लिए बाद में रूपांतरण ।

एक बग के बाद या unsignedअंकगणित के दुरुपयोग के कारण दो को यह सोचना शुरू करना होगा कि क्या अतिरिक्त बिट एक अतिरिक्त परेशानी के लायक है। मैं unsignedअंकगणित में किसी भी प्रकार के उपयोग से बचने के लिए, जितना संभव हो उतना संभव है, हालांकि मैं अभी भी इसका उपयोग गैर-अंकगणितीय संचालन जैसे कि बाइनरी मास्क के लिए करता हूं।

Comments

जावा में "अहस्ताक्षरित लंबे" जोड़ना अजीब होगा। हालांकि, छोटे अहस्ताक्षरित प्रकारों को जोड़ना, कोई समस्या नहीं होनी चाहिए। विशेष रूप से "int" से छोटे प्रकारों को आसानी से संख्यात्मक रूप से स्पष्ट रूप से "int" को बढ़ावा देने के द्वारा नियंत्रित किया जा सकता था, और "अहस्ताक्षरित int" को यह कहकर संभाला जा सकता था कि एक हस्ताक्षरित int और एक अहस्ताक्षरित int से जुड़े ऑपरेशन को बढ़ावा देगा। दोनों "लंबे" के लिए काम करते हैं। एक ही समस्या की स्थिति एक लंबे और हस्ताक्षरित मात्रा में शामिल संचालन होगी, क्योंकि दोनों ऑपरेंड के सभी मूल्यों का प्रतिनिधित्व करने में सक्षम कोई प्रकार नहीं होगा।

— सुपरकैट

@ सुपरकैट: यदि हर ऑपरेशन में unsignedपरिवर्तित हो जाता है तो intइसका क्या उपयोग है unsigned? यह किसी भी कार्यक्षमता से अलग नहीं होगा short। और यदि आप intकेवल मिश्रित ऑपरेशनों में, जैसे कि , unsigned+intया unsigned+floatफिर आप में परिवर्तित हो जाते हैं , तब भी आपको समस्या होती है ((unsigned)25-(unsigned)30)*1.0 > 0, जो कि unsignedसंबंधित कीड़े का एक प्रमुख कारण है ।

— माइकल

अहस्ताक्षरित प्रकारों पर कई ऑपरेशन "लंबे" को बढ़ावा देंगे। परिणामी प्रकारों को वापस संग्रहीत करते समय स्पष्ट कास्ट्स की आवश्यकता होती है, जो शॉर्ट और बाइट के साथ मौजूद होने के साथ ही बहुत अधिक झुंझलाहट का कारण होता है, लेकिन अगर टाइप मुख्य रूप से एक गणना प्रारूप के बजाय एक भंडारण प्रारूप है जो एक समस्या नहीं होनी चाहिए। किसी भी स्थिति में, "int" से छोटे अहस्ताक्षरित प्रकार बिना किसी कठिनाई के "int" को बढ़ावा देने में सक्षम होना चाहिए।

— सुपरकाट

मैं इस उत्तर को नापसंद करता हूं क्योंकि यह तर्क का उपयोग करता है "अहस्ताक्षरित पूर्णांक बुरे हैं और मौजूद नहीं होने चाहिए क्योंकि वे कभी भी हस्ताक्षरित नहीं हो सकते हैं"। एक अहस्ताक्षरित पूर्णांक से घटाने की कोशिश करने वाले व्यक्ति को यह पहले से ही पता होना चाहिए। और पठनीयता के लिए, सी का पालन करने के लिए आसान होने के लिए बिल्कुल ज्ञात नहीं है। इसके अलावा, एक (अर्ध) तर्क "अतिरिक्त बिट अतिरिक्त परेशानी के लायक नहीं है" बहुत कमजोर है। क्या exit(1);वास्तव में 'अतिरिक्त परेशानी के लायक' के बजाय त्रुटि से निपटने के लिए है? क्या बड़ी फ़ाइलों को वास्तव में सुरक्षा के लायक नहीं खोला जा सकता है जो कम अनुभवी जावा प्रोग्रामर उपयोग करने में गड़बड़ी नहीं करेंगे unsigned?

— यनी

इस कोड में मुझे केवल एक ही बुरी चीज दिखती है n - (rays.size() - 1) / 2। आपको हमेशा बाइनरी ऑपरेटरों को ब्रैकेट करना चाहिए क्योंकि कोड के रीडर को कंप्यूटर प्रोग्राम में संचालन के आदेश के बारे में कुछ भी मानने की आवश्यकता नहीं होनी चाहिए। सिर्फ इसलिए कि हम पारंपरिक रूप से a + b c = a + (b c) कहते हैं, इसका मतलब यह नहीं है कि कोड पढ़ते समय आप यह मान सकते हैं। इसके अलावा, अभिकलन को लूप के बाहर परिभाषित किया जाना चाहिए ताकि इसे लूप के बिना परीक्षण किया जा सके। यह अहस्ताक्षरित पूर्णांकों की समस्या के बजाय आपके प्रकारों को सुनिश्चित करने में बग नहीं है। C में यह सुनिश्चित करने के लिए कि आपके प्रकार लाइन अप हैं।

— दिमित्री

Answer 14

'सी' कल्पना में कुछ रत्न हैं जो जावा व्यावहारिक कारणों से गिरा लेकिन जो धीरे-धीरे डेवलपर की मांग (क्लोजर, आदि) के साथ वापस रेंग रहे हैं।

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

मुझे लगता है कि अगर कोई एक डेनिस रिची को पाने के लिए अहंकार बदल रहा था, तो गोसलिंग की डिजाइन टीम को सलाह देने के लिए उसने साइनड के "अनंत पर शून्य" देने का सुझाव दिया था, ताकि सभी पते ऑफसेट अनुरोधों को नकारात्मक मूल्यों को कम करने के लिए अपने ALGEBRAICING SIZE को जोड़ दें।

इस तरह, सरणी में फेंकी गई कोई भी ऑफसेट कभी भी एक SEGFAULT उत्पन्न नहीं कर सकती है। उदाहरण के लिए एक एनकैप्सुलेटेड क्लास में जिसे मैं रिंगअयर ऑफ डबल्स कहता हूं जिसे अहस्ताक्षरित व्यवहार की आवश्यकता होती है - "सेल्फ रोटेटिंग लूप":

// ...
// Housekeeping state variable
long entrycount;     // A sequence number
int cycle;           // Number of loops cycled
int size;            // Active size of the array because size<modulus during cycle 0
int modulus;         // Maximal size of the array

// Ring state variables
private int head;   // The 'head' of the Ring
private int tail;   // The ring iterator 'cursor'
// tail may get the current cursor position
// and head gets the old tail value
// there are other semantic variations possible

// The Array state variable
double [] darray;    // The array of doubles

// somewhere in constructor
public RingArray(int modulus) {
    super();
    this.modulus = modulus;
    tail =  head =  cycle = 0;
    darray = new double[modulus];
// ...
}
// ...
double getElementAt(int offset){
    return darray[(tail+modulus+offset%modulus)%modulus];
}
//  remember, the above is treating steady-state where size==modulus
// ...

उपरोक्त RingArray कभी भी नकारात्मक सूचकांक से 'प्राप्त' नहीं करेगा, भले ही एक दुर्भावनापूर्ण अनुरोधकर्ता ने कोशिश की हो। याद रखें, पूर्व (नकारात्मक) सूचकांक मूल्यों के लिए पूछने के लिए कई वैध अनुरोध भी हैं।

एनबी: बाहरी% मापांक डी-संदर्भ वैध अनुरोध करते हैं जबकि आंतरिक% मापांक नकारात्मक से नकारात्मक प्रभाव को अधिक नकारात्मक मास्क करते हैं। अगर यह कभी जावा + में दिखाई देता था .. + 9 || 8 + .. + कल्पना, तो समस्या वास्तव में एक 'प्रोग्रामर' बन जाएगी, जो "FAULT" को "सेल्फ रोटेट" नहीं कर सकती।

मुझे यकीन है कि तथाकथित जावा अहस्ताक्षरित int 'की कमी' को उपरोक्त वन-लाइनर के साथ बनाया जा सकता है।

पुनश्च: रिंगर्रे हाउसकीपिंग के ऊपर केवल संदर्भ देने के लिए, यहां एक उम्मीदवार 'सेट' ऑपरेशन को उपरोक्त 'तत्व' ऑपरेशन से मिलान करने के लिए:

void addElement(long entrycount,double value){ // to be called only by the keeper of entrycount
    this.entrycount= entrycount;
    cycle = (int)entrycount/modulus;
    if(cycle==0){                       // start-up is when the ring is being populated the first time around
        size = (int)entrycount;         // during start-up, size is less than modulus so use modulo size arithmetic
        tail = (int)entrycount%size;    //  during start-up
    }
    else {
        size = modulus;
        head = tail;
        tail = (int)entrycount%modulus; //  after start-up
    }
    darray[head] = value;               //  always overwrite old tail
}

Answer 15

मैं एक दुर्भाग्यपूर्ण दुष्प्रभाव के बारे में सोच सकता हूं। जावा एम्बेडेड डेटाबेस में, आपके द्वारा 32 बिट आईडी फ़ील्ड के साथ आईडी की संख्या 2 ^ 31 हो सकती है, 2 ^ 32 (~ 2 बिलियन, न कि ~ 4 बिलियन)।

Comments

वह शायद सरणियों के बारे में सोच रहा है और सूचक के रूप में नकारात्मक पूर्णांक का उपयोग करने में सक्षम नहीं हो रहा है। शायद।

— SK9

जब डेटाबेस में ऑटो-इन्क्रीमेंट फ़ील्ड ओवरफ़्लो होती हैं तो वे अक्सर वेक हो जाते हैं।

— जोशुआ

Answer 16

IMHO का कारण यह है कि वे उस गलती को लागू / सही करने के लिए बहुत आलसी थे / हैं। यह सुझाव देते हुए कि C / C ++ प्रोग्रामर अहस्ताक्षरित, संरचना, संघ, बिट फ़्लैग को नहीं समझते हैं ... क्या यह केवल पूर्वसिद्ध है।

किसी भी वास्तविक ज्ञान के बिना आप एक ला सी प्रोग्रामिंग शुरू करने के कगार पर एक बेसिक / बैश / जावा प्रोग्रामर के साथ बात कर रहे थे या आप सिर्फ अपने दिमाग से बात कर रहे हैं। ;)

जब आप हर दिन फ़ाइल या हार्डवेयर से प्रारूप पर सौदा करते हैं, तो आप सवाल करना शुरू करते हैं कि वे नरक में क्या सोच रहे थे।

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

डीसी

Comments

बस किक के लिए, Google वाक्यांश "सेल्फ रोटेटिंग लूप"। स्पष्ट रूप से , डेनिस सह दुनिया में एकमात्र व्यक्ति है जो खुद को / खुद को एक प्रोग्रामर बनाने के योग्य है :-)

— स्टीफन C

यह उत्तर इतना बुरा है कि यह मजाकिया है

— नायुकी