Incrementing an unsigned char array - c

Question

I have a program that takes in an unsigned char ctr[24]. This is going to be used many times and I would like to have a new ctr for each operation. So I would need to either generate a random value each time, or I could initialize it to 0 and increment. I am after performance so generating a new value each time is probably going to be slow versus just incrementing. Is it possible to increment a unsigned char array?
0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00
Increment it by one...
0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x01
etc..
0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x02

Answer 1

Treating unsigned char ctr[24] = {0}; as a counter initialized to 0, the 24 elements can be treated as digits of a base UCHAR_MAX+1 number. Based on the question, the "units" digit is to be stored in ctr[23], the "base1" digit in ctr[22], the "base2" digit in ctr[21], etc. When a digit with value UCHAR_MAX is incremented it will become 0 and a "carry bit" value of 1 needs to be added to the next digit position.
void increment(unsigned char ctr[static 24])
{
unsigned int pos = 24;
while (pos-- && ++ctr[pos] == 0)
;
}
The above function increments an unsigned char[24] in place. It first increments ctr[23] and if it has wrapped around to 0, increments ctr[22], and so forth until one of the digits has not wrapped around to 0, or all of the digits have wrapped around to 0.

Answer 2

You are vanishingly unlikely to really need to....
I mean if you just took the first 8 bytes and treated them as an uint64_t that would run a long, long, time before wrapping around.
Seems to me that some pointer casty stuff and that is job done for any likely use case.
Note that you might need to use some bytes in the middle of your 24 to ensure your memory is aligned suitably for a 64 bit access, but that is a triviality.

Answer 3

void *inc(void *buff, size_t size)
{
unsigned char *cbuff = buff;
for(size_t index = 0; index < size; index++)
{
if(cbuff[index] == 255)
{
cbuff[index] = 0;
}
else
{
cbuff[index]++;
break;
}
}
return buff;
}

Answer 4

I have a program that takes in a unsigned char ctr[24]. This is going to be used many times and I would like to have a new ctr for each operation. So I would need to either generate a random value each time, or I could initialize it to 0 and increment. I am after performance so generating a new value each time is probably going to be slow versus just incrementing. Is it possible to increment a unsigned char array?
Just don't.
Use a simple unsigned long long. It's more than big enough.
At 3 billion increment operations per second, it would take 97 years to roll over a 64-bit value.
unsigned long long is big enough.

Answer 5

Something like this? untested
void add1_recur(unsigned char *x, int lo) {
if (lo < 0) /* 192 bit overflow! */ exit(EXIT_FAILURE);
if (x[lo] == 255) {
x[lo] = 0;
add1_recur(x, lo - 1;)
} else {
x[lo] += 1;
}
}
// add 1 to x; assume x[0] is high order bit
void add1_inplace(unsigned char x[static 24]) {
add1_recur(x, 23);
}

Answer 6

As far as I understand you just need a new pattern each time. Not necessarily a counter.
So would a union do?
Like:
typedef union
{
uint64_t d64[3];
unsigned char d8[24];
} ctr_t;
void p(unsigned char ca[])
{
for (int i=0; i<24; ++i) printf("0x%02X ", ca[i]);
puts("");
}
void change(ctr_t* ctr)
{
// Do some change to each of the three uint64
++ctr->d64[0];
--ctr->d64[1];
++ctr->d64[2];
}
int main(void) {
ctr_t ctr = {{0, 0, 0xff00ff00ff}}; // Just some initialization
p(ctr.d8);
change(&ctr);
p(ctr.d8);
change(&ctr);
p(ctr.d8);
change(&ctr);
p(ctr.d8);
return 0;
}
Output
0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0x00 0xFF 0x00 0xFF 0x00 0x00 0x00
0x01 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x00 0x01 0xFF 0x00 0xFF 0x00 0x00 0x00
0x02 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFE 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x01 0x01 0xFF 0x00 0xFF 0x00 0x00 0x00
0x03 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0xFD 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0xFF 0x02 0x01 0xFF 0x00 0xFF 0x00 0x00 0x00