पॉइंटर एड्रेस और पॉइंटर का मान कैसे बढ़ाया जाए?

Question 1

मान लो की,

int *p;
int a = 100;
p = &a;

निम्नलिखित कोड वास्तव में क्या करेगा और कैसे करेगा?

p++;
++p;
++*p;
++(*p);
++*(p);
*p++;
(*p)++;
*(p)++;
*++p;
*(++p);

मुझे पता है, यह कोडिंग के मामले में एक तरह से गड़बड़ है, लेकिन मैं जानना चाहता हूं कि जब हम इस तरह से कोड करेंगे तो वास्तव में क्या होगा।

नोट: मान लें कि इसका पता a=5120300, यह सूचक में संग्रहीत है pजिसका पता है 3560200। अब, p & aप्रत्येक कथन के निष्पादन के बाद क्या मूल्य होगा ?

Question 2

सबसे पहले, ++ ऑपरेटर * ऑपरेटर पर पूर्वता लेता है, और () ऑपरेटर अन्य चीजों पर पूर्वता लेता है।

दूसरा, ++ नंबर ऑपरेटर नंबर ++ ऑपरेटर के समान है यदि आप उन्हें कुछ भी नहीं दे रहे हैं। अंतर संख्या ++ रिटर्न संख्या और उसके बाद वेतन वृद्धि संख्या, और ++ संख्या वृद्धि पहले है और फिर इसे वापस लौटाता है।

तीसरा, एक पॉइंटर के मूल्य को बढ़ाकर, आप इसे अपनी सामग्री के आकार से बढ़ा रहे हैं, कि आप इसे बढ़ा रहे हैं जैसे कि आप किसी सरणी में पुनरावृत्ति कर रहे थे।

तो, इसे पूरा करने के लिए:

ptr++;    // Pointer moves to the next int position (as if it was an array)
++ptr;    // Pointer moves to the next int position (as if it was an array)
++*ptr;   // The value of ptr is incremented
++(*ptr); // The value of ptr is incremented
++*(ptr); // The value of ptr is incremented
*ptr++;   // Pointer moves to the next int position (as if it was an array). But returns the old content
(*ptr)++; // The value of ptr is incremented
*(ptr)++; // Pointer moves to the next int position (as if it was an array). But returns the old content
*++ptr;   // Pointer moves to the next int position, and then get's accessed, with your code, segfault
*(++ptr); // Pointer moves to the next int position, and then get's accessed, with your code, segfault

जैसा कि यहां बहुत सारे मामले हैं, मैंने कुछ गलती की होगी, अगर मैं गलत हूं तो कृपया मुझे सुधारें।

संपादित करें:

इसलिए मैं गलत था, मैंने जो लिखा है, उससे कहीं अधिक जटिल है, इसे यहां देखें: http://en.cppreference.com/w/cpp/language/operator_precedence

Question 3

कार्यक्रम की जाँच की और परिणाम इस प्रकार हैं,

p++;    // use it then move to next int position
++p;    // move to next int and then use it
++*p;   // increments the value by 1 then use it 
++(*p); // increments the value by 1 then use it
++*(p); // increments the value by 1 then use it
*p++;   // use the value of p then moves to next position
(*p)++; // use the value of p then increment the value
*(p)++; // use the value of p then moves to next position
*++p;   // moves to the next int location then use that value
*(++p); // moves to next location then use that value

Question 4

निम्नलिखित विभिन्न "बस इसे प्रिंट करें" सुझावों का एक तात्कालिकता है। मुझे यह शिक्षाप्रद लगा।

#include "stdio.h"

int main() {
    static int x = 5;
    static int *p = &x;
    printf("(int) p   => %d\n",(int) p);
    printf("(int) p++ => %d\n",(int) p++);
    x = 5; p = &x;
    printf("(int) ++p => %d\n",(int) ++p);
    x = 5; p = &x;
    printf("++*p      => %d\n",++*p);
    x = 5; p = &x;
    printf("++(*p)    => %d\n",++(*p));
    x = 5; p = &x;
    printf("++*(p)    => %d\n",++*(p));
    x = 5; p = &x;
    printf("*p++      => %d\n",*p++);
    x = 5; p = &x;
    printf("(*p)++    => %d\n",(*p)++);
    x = 5; p = &x;
    printf("*(p)++    => %d\n",*(p)++);
    x = 5; p = &x;
    printf("*++p      => %d\n",*++p);
    x = 5; p = &x;
    printf("*(++p)    => %d\n",*(++p));
    return 0;
}

यह लौट आता है

(int) p   => 256688152
(int) p++ => 256688152
(int) ++p => 256688156
++*p      => 6
++(*p)    => 6
++*(p)    => 6
*p++      => 5
(*p)++    => 5
*(p)++    => 5
*++p      => 0
*(++p)    => 0

मैंने सूचक पते intएस को दिए ताकि उनकी तुलना आसानी से की जा सके।

मैंने इसे जीसीसी के साथ संकलित किया।

Question 5

"कैसे एक पॉइंटर पते और पॉइंटर के मूल्य में वृद्धि के संबंध में ?" मुझे लगता है कि ++(*p++);वास्तव में अच्छी तरह से परिभाषित किया गया है और आप जो पूछ रहे हैं, जैसे:

#include <stdio.h>

int main() {
  int a = 100;
  int *p = &a;
  printf("%p\n",(void*)p);
  ++(*p++);
  printf("%p\n",(void*)p);
  printf("%d\n",a);
  return 0;
}

यह अनुक्रम बिंदु से पहले एक ही चीज़ को दो बार संशोधित नहीं कर रहा है। मुझे नहीं लगता कि यह अच्छी शैली है, हालांकि अधिकांश उपयोगों के लिए - यह मेरी पसंद के लिए थोड़ा बहुत गूढ़ है।

Question 6

        Note:
        1) Both ++ and * have same precedence(priority), so the associativity comes into picture.
        2) in this case Associativity is from **Right-Left**

        important table to remember in case of pointers and arrays: 

        operators           precedence        associativity

    1)  () , []                1               left-right
    2)  *  , identifier        2               right-left
    3)  <data type>            3               ----------

        let me give an example, this might help;

        char **str;
        str = (char **)malloc(sizeof(char*)*2); // allocate mem for 2 char*
        str[0]=(char *)malloc(sizeof(char)*10); // allocate mem for 10 char
        str[1]=(char *)malloc(sizeof(char)*10); // allocate mem for 10 char

        strcpy(str[0],"abcd");  // assigning value
        strcpy(str[1],"efgh");  // assigning value

        while(*str)
        {
            cout<<*str<<endl;   // printing the string
            *str++;             // incrementing the address(pointer)
                                // check above about the prcedence and associativity
        }
        free(str[0]);
        free(str[1]);
        free(str);