这个例子不应该改变存储地址而不是改变那个存储地址的值吗？

Question

In a book I am reading, C++ from scratch, on page 113 the writer creates a char array:

myString[80];

then he uses a function that copies some charectars:

strcpy(myString,"Hello there");

then he creates a pointer to the array:

*p1 = myString;

then he uses an offset and assings a value at that offset:

p1[4]='c';

my question is, p1 is a pointer so it is a memory address, and the offset of 4 gives him the memory address 4 spaces in front, so that means he is assingning the letter 'c' to the memory address rather than at the value stored at that address. Shouldnt it be:

*(p1[4])='c';

basically, how come *(p1 + 4) needs dereferencing but p1[4] does not?

I tried to understand this and the only thing that could make sense to me was if the square brackets act as an asterisk to dereference the pointer. Is this correct or is there another reason why p1[4] does not need to be dereferenced?

Answer 1

then he creates a pointer to the array:

 *p1 = myString; 

Assuming, by this, you actually mean that p1 is declared and initialised using;

char *p1 = myString;

then your interpretation is wrong. p1 is a pointer to a char not a pointer to an array.

In this definition, myString is the (previously declared in your question) name of an array of char . In the initialisation

char *p1 = myString;

the name myString is converted to a pointer. That pointer will have the value &myString[0] (ie the address of the first character in myString ). That is the value that p1 will receive.

The statement

 p1[4] = 'c';

will then set the fifth character (since indexing is zero based) of myString to be 'c' . The result is therefore changing myString[4] to the value 'c' . This means that (the first 11 characters of) myString will be "Hellc there" .

Assuming the above, the expression *(p1[4])='c' will not compile, since (p1[4]) is of type char , and cannot be dereferenced using the * operator.

Semantically, in an expression p1[4] is equivalent to *(p1 + 4) . Since p1 is initialised to be equal to &myString[0] , p1[4] is ALSO equivalent to both myString[4] and to *(myString + 4) .

Note: If *(p1[4])='c' was valid in your code, then p1[4] = 'c' would not be valid, which suggests my assumption about the declaration and initialisation of p1 is correct - despite the fact you have omitted such information.

Answer 2

p1 + 4 would be the memory address 4 places beyond.

The expression p1[4] (exactly equivalent to *(p1+4) ) is called an lvalue expression. We say that an lvalue expression designates a memory location. Or in other words, the lvalue expression is synonymous with the memory location itself. You can always use the & address-of operator on an lvalue expression, and that gives you a pointer to the memory location.

The lvalue expression will go on to be used in one of three possible ways:

1. Store a value in the designated memory location, or
2. Retrieve a value from the designated memory location, or
3. Neither of those.

There is no special syntax to distinguish between these three cases; rather it depends on the larger expression of which the lvalue expression is a part of. For example, applying the & operator is case 3; appearing on the left-hand side of the assignment operator = is case 1. Most other usages fall under case 2.

Answer 3

p1[4] is treated as *(p1 + 4) which is "value at an offset of 4 from p1".

Also when you declare a char array:

myString[80]

myString is a pointer to the array (It points to the first element). So when you do myString[4] it is also treated as *(myString + 4)

Writing *(p1[4]) would mean *(*(p1 + 4))