इंक्रीमेंट और डिक्रीमेंट ऑपरेटर

From Vigyanwiki
Revision as of 10:49, 13 May 2023 by alpha>Indicwiki (Created page with "{{Short description|Unary operators that add or subtract one from their operand, respectively}} {{Refimprove|date=September 2014}} इंक्रीमेंट और डि...")
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

इंक्रीमेंट और डिक्रीमेंट ऑपरेटर यूनरी ऑपरेटर ऑपरेटर (प्रोग्रामिंग) हैं जो अपने ओपेरंड को एक से बढ़ाते या घटाते हैं।

वे आमतौर पर अनिवार्य प्रोग्रामिंग प्रोग्रामिंग भाषाओं में पाए जाते हैं। सी (प्रोग्रामिंग भाषा) जैसी भाषाओं में प्रत्येक ऑपरेटर के दो संस्करण (प्री- और पोस्ट-) थोड़े अलग शब्दार्थ के साथ होते हैं।

B (प्रोग्रामिंग लैंग्वेज) (C और इसके विभिन्न डेरिवेटिव सहित) से सिंटैक्टिक रूप से प्राप्त भाषाओं में, इंक्रीमेंट ऑपरेटर को इस रूप में लिखा जाता है ++ और decrement ऑपरेटर के रूप में लिखा गया है --. कई अन्य भाषाएँ inc(x) और dec(x) फ़ंक्शन का उपयोग करती हैं।

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

उन भाषाओं में जो ऑपरेटरों के दोनों संस्करणों का समर्थन करती हैं:

  • प्री-इन्क्रीमेंट और प्री-डिक्रीमेंट ऑपरेटर अपने ऑपरेंड को 1 से बढ़ाते (या घटाते) हैं, और एक्सप्रेशन का मान परिणामी बढ़ा हुआ (या घटा हुआ) मान होता है।
  • पोस्ट-इंक्रीमेंट और पोस्ट-डिक्रीमेंट ऑपरेटर अपने ऑपरेंड के मान को 1 से बढ़ाते (या घटाते) हैं, लेकिन एक्सप्रेशन का मान इंक्रीमेंट (या डिक्रीमेंट) ऑपरेशन से पहले ऑपरेंड का मान होता है।

उन भाषाओं में जहां वृद्धि/कमी एक अभिव्यक्ति नहीं है (उदाहरण के लिए, गो (प्रोग्रामिंग भाषा)), केवल एक संस्करण की आवश्यकता है (गो के मामले में, केवल पोस्ट ऑपरेटर)।

चूंकि इंक्रीमेंट/डिक्रीमेंट ऑपरेटर अपने ऑपरेंड को संशोधित करता है, ऐसे ऑपरेंड का एक ही अभिव्यक्ति के भीतर एक से अधिक बार उपयोग अपरिभाषित परिणाम उत्पन्न कर सकता है। उदाहरण के लिए, x - ++x जैसे भावों में, यह स्पष्ट नहीं है कि किस क्रम में घटाव और वृद्धि संचालन किया जाना चाहिए। ऐसी अभिव्यक्तियां आम तौर पर अपरिभाषित व्यवहार का आह्वान करती हैं, और इससे बचा जाना चाहिए।

सी जैसे टाइप किए गए पॉइंटर्स वाली भाषाओं में, इंक्रीमेंट ऑपरेटर पॉइंटर को उस प्रकार के अगले आइटम पर ले जाता है - उस प्रकार के आकार से पॉइंटर के मान को बढ़ाता है। जब एक सूचक (सही प्रकार का) किसी सरणी में किसी आइटम को इंगित करता है, तो वृद्धि (या कमी) सूचक को उस सरणी के अगले (या पिछले) आइटम पर इंगित करता है। इस प्रकार, एक सूचक को एक पूर्णांक में बढ़ाना इसे अगले पूर्णांक की ओर इंगित करता है (आमतौर पर सूचक मान को 4 से बढ़ाता है);[1] 106 बाइट्स के आकार की संरचना में एक पॉइंटर को बढ़ाने से यह पॉइंटर मान को 106 तक बढ़ाकर अगली संरचना की ओर इशारा करता है।[2]


उदाहरण

निम्नलिखित सी कोड खंड प्री और पोस्ट इंक्रीमेंट और डिक्रीमेंट ऑपरेटरों के बीच अंतर को दर्शाता है: 

int x;
int y;

// Increment operators
// Pre-increment: x is incremented by 1, then y is assigned the value of x
x = 1;
y = ++x;    // x is now 2, y is also 2

// Post-increment: y is assigned the value of x, then x is incremented by 1
x = 1;
y = x++;    // y is 1, x is now 2

// Decrement operators
// Pre-decrement: x is decremented by 1, then y is assigned the value of x
x = 1;
y = --x;    // x is now 0, y is also 0

// Post-decrement: y is assigned the value of x, then x is decremented by 1
x = 1;
y = x--;    // y is 1, x is now 0

इन ऑपरेटरों की कमी वाली भाषाओं में, समकक्ष परिणामों के लिए कोड की एक अतिरिक्त पंक्ति की आवश्यकता होती है: 

# Pre-increment: y = ++x
x = 1
x = x + 1  # x is now 2  (can be written as "x += 1" in Python)
y = x      # y is also 2

# Post-increment: y = x++
x = 1
y = x      # y is 1
x = x + 1  # x is now 2

पोस्ट-इंक्रीमेंट ऑपरेटर आमतौर पर सरणी डेटा संरचना सबस्क्रिप्ट के साथ उपयोग किया जाता है। उदाहरण के लिए: 

// Sum the elements of an array
float sum_elements(float arr[], int n)
{
    float  sum = 0.0;
    int    i   =   0;

    while (i < n)
        sum += arr[i++];    // Post-increment of i, which steps
                            //  through n elements of the array
    return sum;
}

पोस्ट-इन्क्रीमेंट ऑपरेटर का उपयोग आमतौर पर पॉइंटर (कंप्यूटर प्रोग्रामिंग) के साथ भी किया जाता है: 

// Copy one array to another
void copy_array(float *src, float *dst, int n)
{
    while (n-- > 0)        // Loop that counts down from n to zero
        *dst++ = *src++;   // Copies element *(src) to *(dst),
                           //  then increments both pointers
}

ध्यान दें कि ये उदाहरण अन्य C-जैसी भाषाओं में भी काम करते हैं, जैसे C++, Java (प्रोग्रामिंग लैंग्वेज), और C Sharp (प्रोग्रामिंग लैंग्वेज)|C#।

  • इंक्रीमेंट ऑपरेटर को एक उदाहरण द्वारा प्रदर्शित किया जा सकता है:
    #include <stdio.h>
int main()
{
    int c = 2;
    printf("%d\n", c++); // this statement displays 2, then c is incremented by 1 to 3.
    printf("%d", ++c);   // this statement increments c by 1, then c is displayed.
    return 0;
}
    • आउटपुट:
      2
4


सहायक भाषाएँ

निम्नलिखित सूची, हालांकि पूर्ण या सर्व-समावेशी नहीं है, कुछ प्रमुख प्रोग्रामिंग भाषाओं को सूचीबद्ध करती है जो समर्थन करती हैं ++/-- वृद्धि/कमी ऑपरेटरों।

(ऐप्पल की स्विफ्ट (प्रोग्रामिंग भाषा) ने एक बार इन ऑपरेटरों का समर्थन किया था,[12] लेकिन समर्थन संस्करण 3 के रूप में हटा दिया गया था।)

पास्कल (प्रोग्रामिंग भाषा) , डेल्फी (प्रोग्रामिंग भाषा) , मॉड्यूल-2, और ओबेरॉन (प्रोग्रामिंग भाषा) समान कार्य प्रदान करते हैं, लेकिन उन्हें inc(x) और dec(x) कहा जाता है।

विशेष रूप से पायथन (प्रोग्रामिंग लैंग्वेज) और जंग (प्रोग्रामिंग भाषा) इन ऑपरेटरों का समर्थन नहीं करते हैं।

इतिहास

अवधारणा को केन थॉम्पसन द्वारा 1969 के आसपास बी (प्रोग्रामिंग भाषा) में पेश किया गया था।[13]

थॉम्पसन ++ और -- ऑपरेटरों का आविष्कार करके एक कदम आगे बढ़ गया, जो वृद्धि या कमी करता है; उनके उपसर्ग या प्रत्यय की स्थिति यह निर्धारित करती है कि परिवर्तन ऑपरेंड के मान को नोट करने से पहले या बाद में होता है या नहीं। वे बी के शुरुआती संस्करणों में नहीं थे, लेकिन रास्ते में दिखाई दिए। लोग अक्सर अनुमान लगाते हैं कि उन्हें DEC PDP-11 द्वारा प्रदान किए गए ऑटो-इन्क्रीमेंट और ऑटो-डिक्रीमेंट एड्रेस मोड का उपयोग करने के लिए बनाया गया था, जिस पर C और Unix पहली बार लोकप्रिय हुए थे। यह ऐतिहासिक रूप से असंभव है, क्योंकि जब बी विकसित किया गया था तब कोई पीडीपी-11 नहीं था। हालाँकि, PDP-7 में कुछ 'ऑटो-इन्क्रीमेंट' मेमोरी सेल्स थे, इस संपत्ति के साथ कि उनके माध्यम से एक अप्रत्यक्ष मेमोरी रेफरेंस ने सेल को बढ़ा दिया। इस सुविधा ने शायद थॉम्पसन को ऐसे ऑपरेटरों का सुझाव दिया था; उन्हें उपसर्ग और प्रत्यय दोनों बनाने का सामान्यीकरण उनका अपना था। दरअसल, ऑटो-इन्क्रीमेंट सेल का उपयोग सीधे ऑपरेटरों के कार्यान्वयन में नहीं किया गया था, और नवाचार के लिए एक मजबूत प्रेरणा शायद उनका अवलोकन था कि ++x का अनुवाद x=x+1 के मुकाबले छोटा था।

यह भी देखें

संदर्भ

  1. ↑ Richard M Reese. "Understanding and Using C Pointers". "Chapter 4. Pointers and Arrays". O'Reilly Media, Inc. 2013. ISBN 9781449344184
  2. ↑ Richard Petersen. "Introductory C with C++". 2019. Figure 12-12.
  3. ↑ "GNU Awk की उपयोगकर्ता मार्गदर्शिका". Free Software Foundation.
  4. ↑ "8.3. The Double-Parentheses Construct". The Linux Documentation Project.
  5. ↑ Ritchie, Brian W. Kernighan; Dennis M.; Ritchie, Dennis (1988). सी प्रोग्रामिंग भाषा (2. ed., [Nachdr.] ed.). Englewood Cliffs, N.J.: Prentice Hall. p. 18. ISBN 0-13-110362-8.{{cite book}}: CS1 maint: multiple names: authors list (link)
  6. ↑ "Increment/decrement operators". cppreference.com.
  7. ↑ "++ ऑपरेटर (सी # संदर्भ)". Microsoft Developer Network.
  8. ↑ "ऑपरेटर ओवरलोडिंग". dlang.org.
  9. ↑ "जीपी ऑपरेटर और उनकी प्राथमिकताएं".
  10. ↑ "असाइनमेंट ऑपरेटरों के बारे में".
  11. ↑ "इंक्रीमेंट वोल्फ्राम लैंग्वेज सिंबल". Wolfram Language Documentation Center.
  12. ↑ "बेसिक ऑपरेटर्स". developer.apple.com.
  13. ↑ Ritchie, Dennis M. (March 1993). "सी भाषा का विकास". ACM SIGPLAN Notices. 28 (3): 5. doi:10.1145/155360.155580.
Retrieved from ‘https://www.vigyanwiki.in/index.php?title=इंक्रीमेंट_और_डिक्रीमेंट_ऑपरेटर&oldid=163814’