How to convert a byte array to an int array? - c

Question

I'm using a dsPic33F (16 bit microcontroller);
How to convert char[] to int[] such that every two chars becomes an int using C++?
and the inverse operation?

Answer 1

int* intArray = new int[sizeOfByteArray];
for (int i=0; i<sizeOfByteArray; ++i)
intArray[i] = byteArray[i];
Or
std::copy(byteArray, byteArray+sizeofByteArray, intArray);

Answer 2

I guess you want to combine packs of bytes into int?
what you need to do is to shift the bits when you create your int
(oki this is java because I don't have my C ++ code here)
public static final int byteArrayToInt(byte [] b) {
return (b[0] << 24)
+ ((b[1] & 0xFF) << 16)
+ ((b[2] & 0xFF) << 8)
+ (b[3] & 0xFF);
}
public static final byte[] intToByteArray(int value) {
return new byte[] {
(byte)(value >>> 24),
(byte)(value >>> 16),
(byte)(value >>> 8),
(byte)value};
}
this logic works with any conversion formats as long as you know the length of your variables

Answer 3

On a dsPIC 33F, I doubt you're using C++. If you are using C++, what compiler are you using, and how much of a runtime library do you have? (And where did you get it!)
If the byte ordering is correct, you can just use memcpy() if you need a copy, or just cast the pointer if you just want to use the 16 bit numbers in the buffer and the alignment is OK. If you are managing the buffer, it is not unusual to use a union for this kind of requirement on a platform like this:
union my_buffer {
unsigned char char_buf[128];
int int_buf[64];
};
Access through char_buf when dealing with characters, access through int_buf when dealing with ints.
If the bytes need to be swapped, just implement a variant of swab() and use it instead of memcpy(), something like the other answers, or some code like this:
void doit(int16_t* dest, char const* src, size_t word_count)
{
char* const end = (char*) (dest + word_count);
char* p;
for (p = (char*) dest; p != end; src += 2, p += 2) {
p[0] = src[1];
p[1] = src[0];
}
}

Answer 4

I'm not sure if your byte mean char or octet. You may have octets already packed by two in dsPIC's 16-bit words so you have no more to pack them.
#include <limits.h>
#include <stddef.h>
#define BYTE_BIT CHAR_BIT /* Number of significant bits in your 'byte' * Read note below */
/* pack routine */
void ipackc(int *packed, const char *unpacked, size_t nints) {
for(; nints>0; nints--, packed++, unpacked += 2) {
*packed = (unpacked[0]<<BYTE_BIT) | (unpacked[1] & ((1<<BYTE_BIT)-1));
}
}
/* unpack routine */
void cunpacki(char *unpacked, const int *packed, size_t nints) {
for(; nints>0; nints--, packed++, unpacked += 2) {
unpacked[0] = *packed>>BYTE_BIT;
unpacked[1] = *packed & ((1<<BYTE_BIT)-1);
}
}
That's a C code, but there's nothing to deal with C++ features. It compilable in C++ mode. You may replace limits.h and stddef.h with climits and cstddef for tighter C++ conformance.
Note: This code will not work if 2 your 'bytes' cannot fit into int. Check this. Number of bits in int should be not less that 2*BYTE_BIT or one of chars will be lost. If you mean 8-bit octet under 'byte', you may change CHAR_BIT in BYTE_BIT definition to just 8, and then 16-bit int will fit octets correctly.
Note about implementation:
((1<<BYTE_BIT)-1)
is a bit mask for N lower bits, where N=BYTE_BIT. It equal
/--N--\
...011...11 (binary)

Answer 5

I'm assuming that your char array contains bytes (instead of actual ascii characters), which you want to convert into 16-bit signed integers. The function below will work for MSB-first byte ordering. I used unsigned chars here to represent the byte input (uint8_t).
void BytesToInts(uint8_t *byteArray, uint16_t byteArraySize, int16_t *intArray, uint16_t intArraySize) {
//do some error checking on the input
if (byteArraySize == 0) return;
if (intArraySize != (byteArraySize/2)) return;
//convert each pair of MSB-first bytes into a signed 16-bit integer
for (uint16_t i=0; i<intArraySize; i++)
{
intArray[i] = (int16_t) ((byteArray[i<<1]<<8) | byteArray[(i<<1)+1]);
}
}
If you need the integer definitions, you can use something like this:
typedef unsigned short uint16_t;
typedef signed short int16_t;
typedef unsigned char uint8_t;

Answer 6

Here is a compiled and tested method:
#include <stdio.h>
unsigned short ByteToIntArray(
unsigned char inByteArray[],
unsigned short inArraySize,
unsigned short outWordArray[],
unsigned short outArraySize,
unsigned char swapEndian
)
{
if ( ( inArraySize/2 > outArraySize )
|| ( outArraySize == 0 )
|| ( inArraySize == 0 )
)
{
return -1;
}
unsigned short i;
if ( swapEndian == 0 )
{
for ( i = 0; i < outArraySize; ++i )
{
outWordArray[ i ] = ( (unsigned short)inByteArray[ i*2 ] << 8 ) + inByteArray[ i*2 + 1 ];
}
}
else
{
for ( i = 0; i < outArraySize; ++i )
{
outWordArray[ i ] = ( (unsigned short)inByteArray[ i*2 + 1 ] << 8 ) + inByteArray[ i*2 ];
}
}
return i;
}
int main(){
unsigned char ucArray[ 16 ] = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF };
unsigned short usArray[ 8 ];
unsigned short size;
// "/ 2" on the usArray because the sizes are the same in memory
size = ByteToIntArray( ucArray, sizeof( ucArray ), usArray, sizeof( usArray ) / 2, 0 );
if( size > 0 )
{
printf( "Without Endian Swapping:\n" );
for( unsigned char i = 0; i < size ; ++i )
{
printf( "0x%04X ", usArray[ i ] );
}
printf( "\n" );
}
if( size > 0 )
{
// "/ 2" on the usArray because the sizes are the same in memory
size = ByteToIntArray( ucArray, sizeof( ucArray ), usArray, sizeof( usArray ) / 2, 1 );
printf( "With Endian Swapping:\n" );
for( unsigned char i = 0; i < size ; ++i )
{
printf( "0x%04X ", usArray[ i ] );
}
printf( "\n" );
}
return 0;
}
The ByteToIntArray takes 5 parameters and returns the size of the actual converted array, this is handy if you pass in outWordArray that is bigger then the actual converted size and at the same time serves as a way to pick up errors.
A simple bit-wise shift operator and + is used for combining the two bytes into one word.
I just used printf to test the procedures and I'm aware that to use this in embedded hardware usually takes allot of code space. And I just included Endian swapping to make sure you can see what you need to do in both cases but this can easily be removed in your actual implementation.
There is also lot of room for optimization in the ByteToIntArray routine but this way it is easy to understand.