read bits from pointer to array of unsigned char

Question

Say I have an array of unsigned char of 6 bytes.
And some function modifies value in it. How would I retrieve modified values say from 0-19bit?

void my_func()
{
   unsigned char tempVal[6] = { 0,0,0,0,0,0}
   unsigned char* temPtr = &temVal; // Say I am using pt
   int newVal;
   // call external function to modify value 
   // fun below assign new values to tempVal[0].. till tempVal[5].
   void someFuncTomodifyVal( tempPtr );     

   // Now I want values from say 1st19bits
   // how would I achieve that? I know I have to use And condtion with 7FFFF
   // so say somthing like

   newValue  =  *tempPtr & 0x7FFFF // but then *tempPtr will give me first byte only? 
}

So my question is what should I give instead of *tempPtr to get 1st 19 bits

example of

void someFuncTomodifyVal( unsigned char m[] )
{
   m[0] = 'some value retrieve from other funct'
   m[1] = ' values based on some cal'
   m[2] = ' values based on some cal'
}

You don't want or, you want and. Most portable way is to and, shift and or together the bits from the bytes you want. — Sami Kuhmonen, Sep 07 '17 at 13:23
@SamiKuhmonen, Thanks Mate , yes I need And . How would i Use array to And with 0x7FFFF — samprat, Sep 07 '17 at 13:25
Please [edit] your question and show an example of input and expected output. — Jabberwocky, Sep 07 '17 at 13:25
Bits 0 to 19 starting from the beginning or from the end of the `tempVal` array? — Jabberwocky, Sep 07 '17 at 13:29
@MichaelWalz, functions inside calling func will modify tempVal[0] tempVal[1] etc — samprat, Sep 07 '17 at 13:34
That (`someFuncTomodifyVal` function edit) is not an example. An example would be, for a given char array and mask, what actual specific output value do you want to see? At the moment I don't know how you expect endianness to work. — Useless, Sep 07 '17 at 13:35
What is bit 0-19? You seem to make assumptions about a certain endianess. — Lundin, Sep 07 '17 at 13:42
Yes bytes can be of 48bits . and its filled from right to left — samprat, Sep 07 '17 at 15:14

score 1 · Answer 1 · answered Sep 07 '17 at 14:02

1

The main issue here is that you can't take a pointer to unsigned char and wildly cast it to a larger pointer type. This would result in a strict aliasing violation - undefined behavior. This can give incorrectly generated code and similar evil bugs.

To dodge this and access the array through a pointer, you could use a container type that contains the same type among its members:

#include <stdint.h>
#include <string.h>
#include <stdio.h>
#include <inttypes.h>

typedef union
{
  unsigned char u8 [6];
  uint32_t u32;
} my_union_t;

int main()
{
  unsigned char tempVal[6] = { 0x11,0x22,0x33,0x44,0x55,0x66};
  my_union_t* mu = (my_union_t*)tempVal;
  printf("%"PRIx32"\n", mu->u32 & 0x7FFFF);
}

As for what this will print, it depends on CPU endianess - the code is not portable. On my 32 bit little endian CPU I get 32211.

answered Sep 07 '17 at 14:02

Lundin

195,001
40
254
396

Actually he doesn't even cast it to a larger pointer type: `unsigned char* temPtr = &temVal`. Upvoted anyway. – Jabberwocky Sep 07 '17 at 14:10
@MichaelWalz Yeah but obviously that won't work, since that will block the possibility to access the other bytes. – Lundin Sep 07 '17 at 14:11
I'm just curious here, if you have time to look at [this solution](https://gist.github.com/hptk/5a89d6e7d74ba752b6e1831916630b06), is it also violating strict aliasing? I think it is if I understood it correctly. – Hans Petter Taugbøl Kragset Sep 07 '17 at 14:11
@HansPetterTaugbølKragset Indeed it does, it is an almost identical case. – Lundin Sep 07 '17 at 14:12
@Lundin Thanks :) – Hans Petter Taugbøl Kragset Sep 07 '17 at 14:15
1

`(my_union_t*)tempVal` may fail as `my_union_t` and `tempVal` do not have the same alignment requirements. – chux - Reinstate Monica Sep 07 '17 at 14:16
Perhaps `unsigned char tempVal[6]` --> `my_union_t tempVal`? – chux - Reinstate Monica Sep 07 '17 at 14:19
@chux Good point, indeed the best solution is to ditch the raw array and only use the union. Alternatively toss in some asserts for alignment checks. – Lundin Sep 07 '17 at 14:28

Jabberwocky · Accepted Answer · 2017-09-07T14:07:14.653

-1

You probably intended to achieve something like this:

#include <stdio.h>
#include <stdint.h>

int main(void)
{
  unsigned char tempVal[6] = { 0x1,0x2,0x3,0x4,0,0 };
  uint32_t *temPtr = (uint32_t *)tempVal; // Say I am using pt
  uint32_t newVal = *temPtr;

  printf("%08x\n", newVal);
  newVal &= 0x7ffff;
  printf("%08x\n", newVal);
}

On a little endian system the output will be:

04030201
00030201

On a big endian system the output will be:

01020304
01020304

Be aware that this is not portable as it depends on the endianness of the target system and it also violates the strict aliasing rule

Portable and correct solution:

#include <stdio.h>
#include <stdint.h>

int main(void)
{
  unsigned char tempVal[6] = { 0x1,0x2,0x3,0x4,0,0 };

  uint32_t value = 0;
  for (int i = 0; i < 4; i++)
  {
    value <<= 8;
    value |= tempVal[i];
  }

  printf("%08x\n", value);
  value &= 0x7ffff;
  printf("%08x\n", value);
}

edited Sep 07 '17 at 14:07

answered Sep 07 '17 at 13:40

Jabberwocky

48,281
17
65
115

This violates the strict aliasing rule. Bad idea, don't teach this to newbies. – Lundin Sep 07 '17 at 13:44
Also newVal = *temPtr will assign only 1byte from array to newVal. I need 19bits – samprat Sep 07 '17 at 13:45
1

@samprat no, because `temPtr` is a `uint32_t*`. – Jabberwocky Sep 07 '17 at 13:47
@Lundin answer modified. – Jabberwocky Sep 07 '17 at 13:56
The modified answer makes a hard copy though, I'm not sure if this is what the OP wants? – Lundin Sep 07 '17 at 14:03

Pouet_forever · Answer 3 · 2017-09-07T14:05:48.267

-2

Wrong answer

You can use a type which can store the 19 bits. Example : uint32_t *n = (uint32_t *) tempVal;. Now you can get the desired bits (*n) & 0x7FFFF

Good answer

You can use union to respect strict aliasing :

union foo {
    unsigned char   tmp[6];
    unsigned int    n;
};

edited Sep 07 '17 at 14:05

answered Sep 07 '17 at 13:35

Pouet_forever

121
1
7

This violates the strict aliasing rule. Bad idea, don't teach this to newbies. – Lundin Sep 07 '17 at 13:45
Given `unsigned char tempVal[6]`, `uint32_t *n = (uint32_t *) tempVal;` then `(*n) & 0x7FFFF` violates strict aliasing. – Andrew Henle Sep 07 '17 at 13:45

read bits from pointer to array of unsigned char

3 Answers3