Разница указателей между двумя указателями int

Во-первых, ваш код вызывает неопределенное поведение, потому что он читает и изменяет неинициализированные переменные.

Также следует использовать спецификатор %td для вывода разницы указателей.

Предположим, что указатель a действительно указывает на допустимый объект:

int i;
int *a = &i;
int *b = a++;
printf("%td\n",b-a);

Постфиксный оператор ++ дает текущее значение операнда, а затем увеличивает операнд на единицу. Приведенный выше код идентичен:

int i;
int *a = &i+1;
int *b = &i;
printf("%td\n",b-a);

Указатель a указывает на объект i, а указатель b указывает на объект i. Вычитание из-за арифметики указателя даст -1. Если бы операция была: a-b, то результат был бы 1.

Это определенное поведение.

Первая проблема, как я здесь вижу, в первую очередь связана с

 int *a;

a является автоматическим локальным, а начальное значение неопределенно (без явной инициализации), поэтому выполнение a++ (или ++a, если на то пошло) вызывает неопределенное поведение.

Тем не менее, что касается вычитания указателя, см. этот ответ на почему нам нужны операнды оператора вычитания, чтобы быть адресованными элементов из одного объекта массива.

Наконец, вычитание двух указателей дает тип ptrdiff_t, вы должны использовать %td для вывода результата. В противном случае вы снова вызываете UB.

[Как указано в комментариях ниже]

Предполагая, что указатели инициализированы правильно, что-то вроде

int k[5] = {0};
int * a = &(k[0]);
int *b = a++;
printf("%td\n",b-a);

в этом случае результатом будет -1, так как это разница в индексах обоих элементов (помните, что a++ — это пост-инкремент).

Глава §6.5.6/9, C11 стандарт

Когда два указателя вычитаются, оба должны указывать на элементы одного и того же объекта массива или один после последнего элемента объекта массива; результатом является разница индексов двух элементов массива.

Разница двух указателей (в данном случае (b-a)) не определена в C, если только два указателя не указывают на адреса одного и того же массива.

Кроме того, поскольку указателю 'a' в вашем коде не присвоен какой-либо адрес (содержит мусорное значение), выполнение любой операции является грехом.

Если вы хотите увидеть, как работает вычитание двух указателей, попробуйте определить массив и сделать так, чтобы эти два указателя указывали на него.

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

int *a — это переменная с автоматическим сроком хранения, и ее адрес никогда не используется (&a). Поэтому код вызывает неопределенное поведение (согласно 6.3.2.1, см. это), и ваша программа не может иметь предсказуемый результат.

Использование спецификатора формата %d для ptrdiff_t также приводит к неопределенному поведению (7.21.6.1/9). Вы должны использовать %td для ptrdiff_t и %p для указателей.

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

Это нет неопределенного поведения

когда вы объявили *a, a указывает на ячейку памяти, *b = a++; b, чтобы указать на то же местоположение, что и a, И увеличивает a, чтобы указать на местоположение, в 1 раз превышающее предыдущее местоположение, на которое указывает b.

b - a = -1 //правильно

я приведу пример

int main(void)
     {
        int *a; // 0x408
        int *w = a++; // 0x400
        int *b = a++; // 0x404

        int c = (b-a);
        printf("%d\n",b-a);// -1
        printf("%d\n",w-a); // -2

        return 0;
    }

я представляю w, чтобы лучше проиллюстрировать

Адрес памяти во время выполнения переменной будет похож на приведенный выше.

b - a ( 0x404 - 0x408) == -1( -4 );

размер int (в данном случае) составляет 4 байта. и указатели, содержащие адрес int, будут иметь свой адрес, изменяющийся (+/-) с коэффициентом 4, поскольку в этом случае речь идет о int, 4 байта содержат одно целое число (1 единица)

w - a == (0x400 - 0x408) = -2( -8 )

если у тебя есть

a - w == (0x408 - 0x400) = 2( 8 )