How can I change the value in an array when I access a particular element using pointer arithmetic?
#include <stdio.h>
int main() {
int a[3] = {1, 1, 1}, b[3] = {2, 2, 2};
a++ = b++; // How can I get this to work so a[1] = b[1]?
return 0;
}
3 Answers
Arrays are not pointers. Repeat this three times; arrays are not pointers.
You cannot increment an array, it is not an assignable value (i.e., you cannot mutate it). You can of course index into it to get a value back:
a[1] = b[1];
Secondly, your current code is attempting to increment and then assign a new value to the array itself, when you meant to assign to an element of the array. Arrays degrade to pointers when required, so this works too:
int *a_ptr = a;
int *b_ptr = b;
*++a_ptr = *++b_ptr;
// or, better...
a_ptr[1] = b_ptr[1];
Which is what you meant to do. I prefer version 1 and, more often than not, use indexing with pointers as well because it is often easier to read.
11 Comments
beatgammit
or
*++a_ptr = *++b_ptr; for a[1] = b[1];
Felipe Lavratti
Repeat three times... That was funny.
Jim Balter
"Which is what you meant to do." -- No, the OP meant to do
a[1]++ or a[1] = b[1]
Ed Swangren
@JimBalter: I doubt you're correct about the first one, and the second one is the example I gave... my pointer example does the exact same thing but also increments the pointer.
Jim Balter
a) I said "or". If one of the branches of my disjunction is true, then the statement is true. What is in doubt is what the OP meant, and the pedagogical skills of a number of people answering here. b) No, your second example affects
a[0], not a[1], and having the same effect is not being the same. The OP's comment says that a[1] should be the same as b[1] ... nothing about pointer arithmetic; that's an assumption being made by people based on their own knowledge and experience, not that of the OP. |
How can I get this to work so a[1] = b[1]?
Simple:
a[1]++;
if you just wanted to increment a[1] (1) to be what b[1] happens to be (2), or
a[1] = b[1];
if you want a[1] to have the same value as b[1] regardless of what that value is.
when I access a particular element using pointer arithmetic?
In your example, you are not accessing any element, nor are you doing pointer arithmetic because a and b are arrays, not pointers. The formulation of your question is difficult to interpret, both because of that and because
a++ = b++;
1) is completely meaningless 2) would not be legal C even if a and b were pointers, because the left side must be an lvalue, but a++ is not 3) is not discernably related to your wish for a[1] to be the same as b[1]. Possibly what you want is:
int* ap = a; // get pointer to first element of a
int* bp = b; // get pointer to first element of b
// point ap to second element of a and
// point bp to second element of b and
// copy the value at *bp to *ap
*++ap = *++bp;
That would indeed set a[1] to b[1].
11 Comments
paddy
I should point out that while your first option works, it is semantically incorrect. If
a[1] must always assume the value of b[1] then a[1]++ has a totally different meaning, regardless of whether it achieves the same result for the given example. Neither example has anything to do with pointer arithmetic.Jim Balter
"it is semantically incorrect" -- as I said, "depending on exactly what your intent is". The OP didn't say that
a[1] must always assume the value of b[1], so there's no way to know what's semantically correct. "Neither example has anything to do with pointer arithmetic" -- and why the heck do people here assume that the question has anything to do with pointer arithmetic? Remember that the OP is a complete C newbie, and may not intend pointer arithmetic by a++ (which of course doesn't do pointer arithmetic, because a isn't a pointer).Jim Balter
P.S. I, a former member of X3J11 and C programmer for 35 years, am not a newbie and don't need condescending lectures about what has totally different meaning or doesn't have to do with pointer arithmetic.
paddy
Surely you gotta take them at their word when they use the term "pointer arithmetic". Even a newbie who uses that term means what they say. And the semantics... Well, we could split hairs all day. I tried to make a constructive comment. Take it or leave it. =)
Jim Balter
@SeKa There's no way to make people think when reading something, and frankly I don't believe that my clarification makes a whit of difference ... if someone doesn't understand that 1+1 = x = 2 only when x = 2 and not when x has some other value, then they won't be able to make any sense of this or any other SO answer, no matter how detailed.
|
Your arrays in this case are not actually pointers. They are converted by the compiler when they are accessed as pointers, but I don't believe that you're allowed to do something like a++.
If you want to do this with arithmetic, you'll need actual pointers:
int *ap = a, *bp = b;
*ap++ = *bp++;
That is like doing a[0] = b[0]; and then moving each pointer to the next element in their associated array.
But your question says you want to set a[1] = b[1]. Well, you could do this:
*++ap = *++bp;
Or you could just use the array indices and make it much more obvious what you're doing.
5 Comments
Jim Balter
"They are converted by the compiler when they are accessed as pointers" -- No, they are "converted" by the language specification when passed to functions that have pointer arguments ... that is, the address of the first element of the array is passed to the function rather than the whole array, because arrays aren't first class objects in C (they can't be because their length isn't stored). "I don't believe you're allowed to do something like a++" -- indeed, because
++ is not a function call.Jim Balter
"when passed to functions that have pointer arguments" -- actually I should have said "when assigned to pointers" -- which being passed to pointer parameters is an instance of.
newacct
@JimBalter: they are actually converted to pointers in any context except the
& operator and sizeof (and typeof in places that support it), not just when passedJim Balter
@newacct Right ... I seem to keep leaving things out. Also I offer this correction to my comment above: "I don't believe you're allowed to do something like a++" -- indeed, because
a is converted to &a[0], which is not an lvalue.paddy
In light of all this, is it actually wrong for me to say they are "converted by the compiler when accessed as pointers"? To me, that means the compiler understands you are trying to use the array as if it was a pointer (as per the language specification), and it does the appropriate conversion.
*(a+1) = *(b+1), as this would do the arithmetic without trying to update the variables themselves likea++would. Question is why you'd want to: the indexed form, as you have already showna[1] = b[1]is equivalent and much easier to read.