How can i insert integer in char array in c++ using shifting? - c++

Question

I am really new to c++ so sorry if this question is bad or not understandable.
I have an integer, for example, int a; its values can be between 1 and 3500 (this value I get from a file). I also have an array of chars, unsigned char packet[MAX_PACKET_SIZE];. My goal is to place this integer value in this array between indexes packet[10] and packet[17] So in the end takes 8 bytes.
If the value for a is 1 i would like my packet array to be:
packet[10] = 30, packet[11] = 30, packet[12] = 30, packet[13] = 30, packet[14] = 30, packet[15] = 30, packet[16] = 30, packet[17] = 31

Answer 1

You have to look into binary representation and binary math to really understand what bit-wise operations do to values.
Note that 3500 easily fits into a 16 bits value, 3500 is less than 2^16.
If you want to use types with guaranteed sizes, you have to use uint8_t, uint16_t and similar.
Such operations require a careful approach in case of C++, if you want a potable code. An int may have different size and even different order of bytes (endianness), but operators of bit-wise shift >> and << are agnostic to endianness. Operator << always shift toward higher digits, >> always shifts to less significant ones.
Note, that in C++ results of all bit-wise operations are promoted to be of size of unsigned int or larger type if required. Shift operations with signed values are not defined.
In naive but safe variant of required algorithm we have to do those steps.
(Decide in which order we write bytes down into the buffer. Let assume we do that from less significant to more significant.)
Determine first byte to write value to to, pointed by p
Determine size of written value in bytes, a pend pointer defines a byte after the written value.
"Cut" first byte out of the original value by using AND operation (&) and mask consisting of all 1's and assign it to the location pointed by p.
Remove written byte from value by shift to the right (>>).
Increment p.
If (p != pend) go to 3.
(optional) we can save p or pend for further purposes, e.g. for sequenced writes.
In C-styled (but already C++) variant this would look like:
unsigned char * pack_int(unsigned char *p, unsigned value)
{
unsigned char *pend = p + sizeof(value);
while(p != pend)
{
// ~ is a bit-wise not, ~0 produces an int with all bits set
*p = value & ((unsigned char)~0);
value >>= CHAR_BIT;
p++;
}
return p;
}
Use of ((unsigned char)~0) instead of 0xFF literal is simply a protection from bytes that aren't 8 bit. Compiler would convert it into correct literal value.
C++ allows to make this implementation to be type-agnostic. E.g. one that still requires sequenced iterators to address output location:
template <class InIt, class T>
InIt pack(InIt p, T value)
{
using target_t = std::make_unsigned_t<std::remove_reference_t<decltype(*p)>>;
using src_t = std::make_unsigned_t<T>;
InIt pend = p + sizeof(T);
src_t val = static_cast<src_t> (value); // if T is signed, it would fit anyway.
while(p != pend)
{
*p = (val & (target_t)~0);
val >>= CHAR_BIT;
p++;
}
return pend;
}
In C++17 one can use
InIt pend = p;
std::advance(pend, sizeof(T));
A better implementation in C++ would generate conversion sequence statically, during compilation, instead of using a loop, by application of recursive templates.
This is a fully functional program that uses both :
#include <iostream>
#include <array>
#include <climits>
#include <type_traits>
// C-styled function
// packs value into buffer, returns pointer to the byte after its end.
unsigned char * pack_int(unsigned char *p, unsigned value)
{
unsigned char *pend = p + sizeof(value);
while(p != pend)
{
// ~ is a bit-wise not, ~0 produces an int with all bits set
*p = value & ((unsigned char)~0);
value >>= CHAR_BIT;
p++;
}
return p;
}
// a type-agnostic template
template <class InIt, class T>
InIt pack(InIt p, T value)
{
using target_t = std::make_unsigned_t<std::remove_reference_t<decltype(*p)>>;
using src_t = std::make_unsigned_t<T>;
InIt pend = p + sizeof(T);
src_t val = static_cast<src_t> (value); // if T is signed, it would fit anyway.
while(p != pend)
{
*p = (val & (target_t)~0);
val >>= CHAR_BIT;
p++;
}
return pend;
}
int main(int argc, char** argv )
{
std::array<unsigned char, 16> buffer = {};
auto ptr = pack_int(&(buffer[0]), 0xA4B3C2D1);
ptr = pack(ptr, (long long)0xA4B3C2D1);
pack(ptr, 0xA4B3C2D1);
std::cout << std::hex;
for( auto c : buffer)
std::cout << +c << ", ";
std::cout << "{end}\n";
}
Output of this would be
d1, c2, b3, a4, d1, c2, b3, a4, 0, 0, 0, 0, d1, c2, b3, a4, {end}
The sequence d1, c2, b3, a4, repeated twice, is obviously a reversed representation for hex value 0xA4B3C2D1. On little-endian system that matches representation of unsigned int in memory. For 3500 (hex 0xDAC) it would be ac, d, 0, 0.
In communications a "network order" is accepted as a standard, also known as "big-endian", where the most significant byte comes first, which would require a slight alteration to the algorithm above.