Làm thế nào để tăng địa chỉ con trỏ và giá trị của con trỏ?

Hãy để chúng tôi giả sử,

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

Đoạn mã sau thực sự sẽ làm gì và như thế nào?

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

Tôi biết, điều này khá lộn xộn về mặt mã hóa, nhưng tôi muốn biết điều gì sẽ thực sự xảy ra khi chúng tôi viết mã như thế này.

Lưu ý: Giả sử rằng địa chỉ của a=5120300nó được lưu trữ trong con trỏ pcó địa chỉ 3560200. Bây giờ, giá trị p & asau khi thực hiện mỗi câu lệnh sẽ là bao nhiêu?

Đầu tiên, toán tử ++ được ưu tiên hơn toán tử * và các toán tử () được ưu tiên hơn mọi thứ khác.

Thứ hai, toán tử số ++ giống với toán tử số ++ nếu bạn không gán chúng cho bất kỳ thứ gì. Sự khác biệt là số ++ trả về số rồi sau đó tăng số, và số ++ tăng trước rồi trả về.

Thứ ba, bằng cách tăng giá trị của một con trỏ, bạn đang tăng nó theo kích thước nội dung của nó, tức là bạn đang tăng nó như thể bạn đang lặp lại trong một mảng.

Vì vậy, tóm lại tất cả:

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

Vì có rất nhiều trường hợp ở đây, tôi có thể đã mắc một số sai lầm, vui lòng sửa cho tôi nếu tôi sai.

BIÊN TẬP:

Vì vậy, tôi đã sai, mức độ ưu tiên phức tạp hơn một chút so với những gì tôi đã viết, hãy xem nó tại đây: http://en.cppreference.com/w/cpp/language/operator_precedence

đã kiểm tra chương trình và kết quả là,

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

Sau đây là bản tóm tắt các gợi ý "chỉ cần in nó". Tôi thấy nó có tính hướng dẫn.

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

Nó trở lại

(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

Tôi chuyển địa chỉ con trỏ thành ints để chúng có thể dễ dàng so sánh.

Tôi đã biên dịch nó với GCC.

Liên quan đến "Làm thế nào để tăng địa chỉ con trỏ và giá trị của con trỏ?" Tôi nghĩ rằng điều đó ++(*p++);thực sự được xác định rõ ràng và thực hiện những gì bạn đang yêu cầu, ví dụ:

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

Nó không sửa đổi cùng một thứ hai lần trước một điểm trình tự. Tôi không nghĩ rằng đó là phong cách tốt cho hầu hết các mục đích sử dụng - nó hơi khó hiểu so với sở thích của tôi.

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