What does *--a = *--b mean in C - c

Question

Suppose a and b are pointers,
My understanding is *--a = *--b means subtract 1 from a and b using pointer arithmetic, then dereference a and b and set them equal.
Is this equivalent to
--a;
--b;
*a=*b
Similarly, what is
*a++ = *b++;
equivalent to?

Answer 1

*––a = *––b
is logically equivalent to
tmpa = a - 1
tmpb = b - 1
*tmpa = *tmpb
a = a - 1
b = b - 1
with the caveat that the updates to a, b, and *tmpa can occur in any order, and those updates can even be interleaved. It’s also possible for the implementation to skip the temporaries and update the pointer values immediately:
a = a - 1
b = b - 1
*a = *b
but that’s not required or guaranteed. Similarly,
*a++ = *b++
is logically equivalent to
tmpa = a
tmpb = b
*tmpa = *tmpb
a = a + 1
b = b + 1
with the same caveats about the ordering of the updates to a, b, and *tmpa. Again, the implementation may skip using temporaries and evaluate it as
*a = *b
a = a + 1
b = b + 1
but again that’s neither required nor guaranteed.

Answer 2

*a++ = *b++;
dereference b and assign it to where a points. The ++ is the postfix operator, so the current value of *b will be assigned to *a, then both will be incremented.
If you keep this in a while loop, all the characters from b will be copied to a including the \0. This continues as long as *a++ = *b++ is not \0, at which time loop terminates.
while(*a++ = *b++);
Example :
#include <stdio.h>
int main()
{
char a_arr[30] = {0};
char b_arr[] = "Hello,World";
char *a = a_arr;
char *b = b_arr;
while(*a++ = *b++);
puts(a_arr);
puts(b_arr);
return 0;
}

Answer 3

Example
uint8_t *a = 1030; // POINTS TO ADDRESS 1030
uint8_t *b = 1020; // POINTS TO ADDRESS 1020
printf("%d", *(--a)); // PRINTS VALUE ON ADDRESS 1029
printf("%d", *(b++)); // PRINTS VALUE ON ADDRESS 1021
*(--a) subtracts one byte(one address) because pointer a points to one byte(it is uint8_t). After subtraction, it will read value from address.
*(--something) you can write as
uint32_t *c = 1050;
c -= 1; // SUBCTRACTS 4 BYTE ADDRESS FROM POINTER c
print("%d", *c);
Why 4 bytes you may ask? Because pointer c points to four byte(uint32_t or int32_t) data. You can get size of data in bytes with sizeof(variable).
In your case, lets say pointer a points to address 40. Pointer b points to address 50.
Address 39 holds value 1
Address 40 holds value 2
Address 50 holds value 10
Address 51 holds value 11
uint8_t *a = 40;
uint8_t *b = 50;
printf("%d", *(--a));
printf("%d", *(b++));
First printf will print value 1. Second printf will print value 50.
After printf pointer a points to address 39 and pointer b points to address 51
Reason? In first printf, it will first subctract one address(again, one because it points to one byte value), and then it will dereference value(that is why we use * for reading the value from pointer address).
In second printf, it will first dereference value and then move pointer one address up.