How to modify more than 1 Byte in an array?

Question

What I am trying:

BYTE test[] = {0x00,0x00,0x00,0x00};
*(test+1) = 0xFFFF;

What I get:

00000000 11111111 00000000 00000000

What I expect or want to achieve:

00000000 11111111 11111111 00000000

Background: In one part of my program I need to insert a WORD into a part of an array. Yes, normally I could just do

*(test+1) = 0xFF;
*(test+2) = 0xFF;

but I wonder if there is a possibility to do this as a one-liner like in the first example. Memcpy is no option here since I would need to allocate space for a second array.

The short answer is 'no'. The long answer involves type-punning through unions. Unless, that is, you really are just trying to set the values as Alok Singhal showed in his answer using memset. — Christian Gibbons, Feb 21 '19 at 19:44
@IłyaBursov That breaks strict aliasing and is undefined behavior. — Christian Gibbons, Feb 21 '19 at 19:45
I was about to say 'no' unless you play with types and such, but since @ChristianGibbons already said it, so I'm not gonna say it now :D — sid-m, Feb 21 '19 at 19:47
"Memcpy is no option here since I would need to allocate space for a second array." This makes little sense. First, paraneters to `memcpy` need not be arrays, an address of a single integer will do. Second, if you for some reason do need a second array (you don't but let's pretend), it would be of whoppin' two elements. Allocating such an array on the stack is not a problem. — n. m. could be an AI, Feb 21 '19 at 19:47
@IłyaBursov It is a one-way street (and technically it's character types, so `char`, `signed char`, and `unsigned char` specifically). Character-types can alias any other type, but not the other way around. — Christian Gibbons, Feb 21 '19 at 19:48
`memset` is your friend but … why? why not write the code simple and easy to understand - like: `test[1]=0xff; test[2]=0xff;` done... easy to write - easy to understand. If you need to set many elements then `memset` is good. Alternatively make a `for`-loop — Support Ukraine, Feb 21 '19 at 19:52

score 5 · Answer 1 · answered Feb 21 '19 at 19:44

5

For this case, memset(test+1, 0xFF, 2) should work.

answered Feb 21 '19 at 19:44

Alok Singhal

93,253
21
125
158

Excellent! Good compilers will generate a single instruction on x86 targets, as can be seen on https://gcc.godbolt.org/z/WmgIjo . Unaligned writes are OK on these targets for most OSes. – chqrlie Feb 21 '19 at 20:05

Antti Haapala -- Слава Україні · Accepted Answer · 2019-02-21T20:13:48.697

Your options are

```
test[1] = 0xFF;
test[2] = 0xFF;
```
```
memset(test + 1, 0xFF, 2);
```

const char bytes[2] = {0xFF, 0xFF};
memcpy(test + 1, bytes, 2);

uint16_t value = 0xFFFF;     // beware of byte order
memcpy(test + 1, &value, 2);

memcpy(test + 1, (const unsigned char []){0xFF, 0xFF}, 2));

or any other code that addresses the individual bytes separately.

What is not an option is:

*(uint16_t)&test[1] = 0xFFFF;

The reason is simple: it breaks two rules in C: strict aliasing and alignment. What is worse is that you can get away with this in this part of code, but dereferencing unaligned uint16_t pointers is never safe, even on x86-64 that supposedly supports unaligned accesses

0___________ · Answer 3 · 2019-02-21T20:24:15.720

#define modify(dest,src,pos)    do { unsigned char *tmp =(void *)&dest; memcpy(tmp + pos,&src, sizeof(src));}while(0)

void *modify1(void *dest, void *src, size_t pos, size_t len)
{
    unsigned char *tmp = dest;
    memcpy(tmp + pos, src, len);
    return tmp + pos;
}

examples:

char x[10];
short y = 0xffff;
modify(x,y,3);

or modify1(x,&y, 3, sizeof(y));

Note that the macro one will not work in all circumstances.

aminosbh · Answer 4 · 2019-02-21T20:06:04.613

-2

The following code is a generic solution that let you write a value of 2 Bytes (16 bits) into successive cells of an array :

uint16 data = 0xFFFF;

BYTE test[] = {0x00,0x00,0x00,0x00};
*(test+1) = data & 0xFF;
*(test+2) = data >> 8;

The result will be:

00000000 11111111 11111111 00000000

So just change the value of data.

edited Feb 21 '19 at 20:06

answered Feb 21 '19 at 19:48

aminosbh

193
1
5

That just seems like a more complicated version of OPs original code (adding unnecessary bitwise operations) – UnholySheep Feb 21 '19 at 19:50
I assumed that the value to be written may change. This is a more generic solution. – aminosbh Feb 21 '19 at 19:53
Why create a `uint16` if your only intent is to access its individual constituent bytes? – Govind Parmar Feb 21 '19 at 19:56
The `uint16 data` is just an example of 2 Bytes data that could be written. So we can even wrap it into a function. – aminosbh Feb 21 '19 at 19:59

How to modify more than 1 Byte in an array?

4 Answers4