Bagaimana cara menaikkan alamat penunjuk dan nilai penunjuk?

Mari kita asumsikan,

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

Apa yang sebenarnya akan dilakukan kode berikut dan bagaimana caranya?

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

Saya tahu, ini agak berantakan dalam hal pengkodean, tetapi saya ingin tahu apa yang sebenarnya akan terjadi ketika kita membuat kode seperti ini.

Catatan: Mari kita asumsikan bahwa alamat a=5120300, disimpan di pointer pyang alamatnya adalah 3560200. Sekarang, berapa nilai p & asetelah eksekusi setiap pernyataan?

Pertama, operator ++ lebih diutamakan daripada operator *, dan operator () lebih diutamakan daripada yang lainnya.

Kedua, operator nomor ++ sama dengan operator nomor ++ jika Anda tidak menugaskannya ke apa pun. Perbedaannya adalah angka ++ mengembalikan angka dan kemudian menambah angka, dan ++ angka bertambah terlebih dahulu dan kemudian mengembalikannya.

Ketiga, dengan meningkatkan nilai sebuah pointer, Anda menambahnya dengan ukuran isinya, yaitu Anda menambahnya seolah-olah Anda sedang mengulang dalam sebuah array.

Jadi, untuk merangkum semuanya:

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

Karena ada banyak kasus di sini, saya mungkin telah membuat kesalahan, mohon koreksi saya jika saya salah.

EDIT:

Jadi saya salah, yang diutamakan sedikit lebih rumit dari yang saya tulis, lihat di sini: http://en.cppreference.com/w/cpp/language/operator_precedence

cek programnya dan hasilnya seperti,

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

Berikut ini adalah contoh dari berbagai saran "cetak saja". Saya merasa itu instruktif.

#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;
}

Ia kembali

(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

Saya mentransmisikan alamat pointer ke ints sehingga mereka dapat dengan mudah dibandingkan.

Saya menyusunnya dengan GCC.

Berkenaan dengan "Bagaimana cara menaikkan alamat pointer dan nilai pointer?" Saya pikir itu ++(*p++);sebenarnya didefinisikan dengan baik dan melakukan apa yang Anda minta, misalnya:

#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;
}

Ini tidak mengubah hal yang sama dua kali sebelum titik urutan. Saya tidak berpikir itu gaya yang baik untuk sebagian besar penggunaan - itu agak terlalu samar untuk saya sukai.

        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);