Указатели до/после приращения

Question

Может ли кто-нибудь объяснить этот код полностью?

#include<stdio.h> 
#include<stdlib.h> 

int main() 
{ 
    int *a, *s, i; 

    a = s = (int *) malloc(4 * sizeof(int)); 

    for (i = 0; i < 4; i++) 
    { 
     *(a + i) = i * 10; 
     printf(" %d ", *(a + i)); 
    } 

    printf("\n"); 
    printf("%d\n", *s++); 
    printf("%d\n", (*s)++); 
    printf("%d\n", *s); 
    printf("%d\n", *++s); 
    printf("%d\n", ++*s); 
    printf("\n"); 
    printf("%d\n", *a++); 
    printf("%d\n", (*a)++); 
    printf("%d\n", *a); 
    printf("%d\n", *++a); 
    printf("%d\n", ++*a); 

    return 0; 
} 

выход:

0 10 20 30 
0 
10 
11 
20 
21 

0 
11 
12 
21 
22 

1) Как указатель 's' печатает значения, где *(a+i) только были назначены значения в течение цикла?

2) Где значение точно сохраняется и сохраняется при назначении *(a+i)?

3) В чем разница между *s++, (*s)++, *++s, ++*s?

4) Почему значения увеличиваются на 1, когда я печатаю указатель, аналогичный s?

Спасибо заранее! :)

Answer 1

Вам нужно сначала изучить указатели. Может быть, это может помочь: http://www.cs.cf.ac.uk/Dave/C/node10.html

Answer 2

1)

Переменной a и s указуют на то же место памяти.

2)

если вы говорите a + 1, вы увеличиваете значение указателя a на 1 разы размера его типа (1 * 4). Итак, если вы скажете *(a+1), вы берете значение из следующего целого числа. Вы можете представить свою переменную как массив, поскольку она указывает на расположение памяти размером 4 целых числа. Вы также можете получить доступ к следующим значениям: a[0], a[1], a[2] and a[3].

3)

*s++: Берешь значение этого указателя и после этого заявления, указатель s увеличивается на 4.

`(* с) ++ ': Берешь значение указатель, а затем увеличьте это значение на 1.

*++s: Вы увеличиваете указатель s на 4, а затем берете его значение.

++*s: Берешь значение указателя s и увеличиваем его на 1.

4)

Поскольку указатель s и указатель a указывают на то же место памяти, и вы называете *s++, в значение этого местоположение памяти увеличивается на единицу.

Answer 3

1 и 2) Указатель указывает на (или вы можете сказать, что это адрес) определенной ячейки памяти. Поскольку вы назначаете a = s = (int*) malloc(4 * sizeof(int));, a и s оба имеют один и тот же адрес или указывают на одно и то же место в памяти. Если что-либо изменяется на содержимое в памяти (например,в вашем коде вы присваиваете номера выделенной памяти), то до тех пор, пока у вас есть правильный адрес (оба a и s указывают на то же местоположение), вы можете увидеть изменений.

Грубая аналогия заключается в том, что вы просите дом (malloc), и он возвращает вам адрес дома (a). Затем вы решаете, что дом уродлив, и вы хотите его перекрасить (присвойте значение: *(a + i) = i + 10), другие люди, которые вы указали по адресу (s), увидят, что ваш дом перекрашен.

3)

*s++ означает доступ к контенту по текущему адресу, а позже увеличивает указатель (адрес).

Откликнуться на ваш код, он обращается к первому элементу, после чего адрес укажет на второй элемент.

(*s)++ означает доступ к контенту по текущему адресу, а позже увеличивает содержание по текущему адресу.

Обратите внимание на свой код, он получает содержимое второго элемента, прежде чем увеличивать его. Следующий оператор печати показывает, что содержимое второго элемента было увеличено.

*++s означает приращение текущего адреса и доступ к содержимому с с приращением.

Обратите внимание на свой код, он получает содержимое третьего элемента.

++*s означает приращений содержание по текущему адресу, а также доступ к увеличивается содержание.

Возвращайтесь к своему коду, он получает увеличенное содержимое третьего элемента.

4) Как пояснялось в предыдущей части, если вы изменяете содержимое с помощью одного указателя, вы увидите его, если у вас есть тот же указатель (адрес). Фактически вы изменяете содержимое адресов памяти (как описано в 3), поэтому вы можете увидеть эффект модификации, когда вы повторяете процесс.

Answer 4

a=s= (int *) malloc(4*sizeof(int)); 

это утверждение распределения памяти для «s» анс та же память присваивается «а» , например, я Виль рассказ адрес, назначенный в 2000, как правило, это будет в шестнадцатеричном только для понимания я буду принимать десятичное стоимость. для (I = 0; я < 4; я ++)

{ 

    *(a+i)=i*10; 

printf(" %d ",*(a+i)); 

    } 

, когда у делать (а + я) адрес добавляется с г ....а + 0 = 2000 (как в примере) а + 1 = 2004 (следующие ячейки памяти), так как это INT указатель будет увеличиваться на 4 (размер INT)

  +--------+---------+----------+---------+ 
     |0  | 10 |  20 | 30 | 
     |  |   |   |   | 
     +--------+---------+----------+---------+ 
Address 2000  2004  2008  2012 

* (а + я) Виль дайте u содержимое только для памяти (a + i) или wil, дайте u адрес , поскольку ур, присваивающий s одному и тому же значению , теперь теперь * s ++ теперь s is 2000 * s равно 0 и s ++ имеет место для следующего использование с будет в 2004 месте, чтобы его 0 следующий ур * s 10 и (* s) ++ Виль пост инкремент 10 поэтому его 11 следующего использования

см приоритет и ассоциативность, чтобы знать, как он компилирует

http://msdn.microsoft.com/en-us/library/126fe14k%28v=vs.80%29.aspx