Convert char array to integer equivalent and vice-versa - c

Question

I am trying to build a simple function to handle block striping onto a "fake" disk (implemented in memory as a nested array of n blocks of x bytes represented by 4 byte ints, stored to a regular file on close). Data is passed into my write_block function as an array of chars from the buffer in my open-file table (OFT).
In order to do this my thought process is to convert my array of chars to an integer value in blocks of 4 chars (the logic being 4x1 byte chars is equivalent to 1x4 byte integer) by using the following function:
//write_block(index, block_pointer)
// write block, start with array of characters and write integers to ldisk (convBlock == converted Block)
// return: 1 if successful, -1 if not
int write_block(int blockIndex, char *convBlock) {
if (strlen(convBlock) > blockSize) {
printf("Block passed to write exceeds max block size\n");
return -1;
}
int i, j;
int scalar, currIndex;
for (i = 0; i < strlen(convBlock) / sizeof(int) + ((strlen(convBlock) % sizeof(int) == 0) ? 0 : 1); i++) {
scalar = 1;
for (j = 0; j < sizeof(int); j++) {
currIndex = (i * sizeof(int) + j);
if (currIndex > strlen(convBlock))
break;
ldisk[blockIndex][i] += convBlock[i] * scalar;
scalar *= 1000;
}
}
return 1;
}
However, this doesn't work because the maximum size of an unsigned 4 bit integer is 4294967295 (10 digits), while converting a char array this way results in 12 digits (3 per char). I know I should technically be able to do this since a char takes up a single byte, while an integer takes 4.
My next thought was to convert to binary then convert back to an integer. However, I would need to somehow store the binary representation of 4 chars back to back which would require an integer with 4*8 = 32 digits, while the max size of the largest numeric type (long long) is 18446744073709551615 (20 digits).

Answer 1

My understanding of your goal is you want to store a null terminated block of characters to a virtual disk made of integers into block blockIndex.
Here is a simplified version of your function that can handle different storage types: 4 byte ints or 8 byte ints:
#include <stdint.h>
//write_block(index, block_pointer)
// write block, start with array of characters src and write integers to ldisk
// return: 1 if successful, -1 if not
int write_block(int blockIndex, const char *src) {
size_t i, j, k, size;
size = strlen(src) + 1; // include the null terminator in the written conversion.
if (size > blockSize) {
printf("Block passed to write exceeds current block size\n");
return -1;
}
for (i = j = k = 0; i < size; i++) {
ldisk[blockIndex][j] &= ~(0xFFULL << k);
ldisk[blockIndex][j] |= (unsigned long long)(unsigned char)src[i] << k;
k += 8;
if (k == sizeof(ldisk[blockIndex][j]) * 8) {
j++;
k = 0;
}
}
return 1;
}
Notes:
I included the null terminator in the conversion so the reading code knows where to stop.
The char values must be cast as unsigned char to avoid sign propagation in case char type is signed, which is the default on many systems.
You should return the number if blocks written (j) to the caller. This is useful information, and can easily be distinguished from -1 for errors.
This code does assume that char has 8 bits. Using CHAR_BITS instead of 8 would allow for other values with some other constant adjustments, if you really seek full compatibility with exotic platforms.
I use unsigned long long arithmetic to allow for the storage unit to be as large as possible.