Reconstructing an integer using bitwise operators

I'm working on an assignment in which I have to generate a random number of variable sizes, store each individual byte inside of an array, and then reconstruct that number by concatenating the bytes.

For example, if our number is the 16 bit binary 1100001111110000, we would have one function which puts this number into an array. Our array would contain 2 indices: 110000111 and 1110000. Then we have another function that knows the size, and combines the two indices to create the original number.

We then have to calculate the sum of all of the 16-bit integers in our array. Here is what I have for loading the data and summing it mem[] is a block which has been allocated using malloc of size size:

void loadhalfwdata(char mem[], int size) {
    int i, result;
    for (i = 0; i < (size >> 1); i++) {
        result = (rand() & 0x7fff);
        *mem = (char)(result >> 8);
        *(mem + 1) = (char)(result & 0xff);
        mem += 2;
    }
}

int sumhalfwdata(char mem[], int size) {
    int i, sum, result;
    sum = 0;
    for(i = 0; i < (size >> 1); i++) {
        result = *mem << 8;
        result |= (*(mem + 1) & 0xff);
        sum += result;
        mem+= 2;
    }

    return sum;
}

This works, and everything is great! Now when I try and extend this to a 32bit integer, things don't seem to work so nicely.

void loadworddata(char mem[], int size) {
    int i, result;
    for(i = 0; i < (size >> 2); i++) {
        result = (rand() & 0x7fffffff);
        *mem = (char)(result >> 24);
        *(mem + 1) = (char)(result >> 16 & 0xff);
        *(mem + 2) = (char)(result >> 8 & 0xff);
        *(mem + 3) = (char)(result & 0xff);
        mem += 4;
    }
}

int sumworddata(char mem[], int size) {
    int i, sum, result;
    sum = 0;
    for(i = 0; i < (size >> 2); i++) {
        result = (*mem << 24) | ( *(mem + 1) << 16 ) | ( *(mem + 2) << 8 ) | ( *(mem + 3) );
        sum += result;
        mem += 4;
    }

    return sum;
}

I found a function online to help me convert these integers to binary, and when I load the number this is the output:

LOADING WORD:
Word: 1102520059
As Binary: 01000001101101110001111011111011
First 8 bits: 01000001

Second 8 bits: 10110111

Third 8 bits: 00011110

Fourth 8 bits: 11111011

However when I do the same thing in the sum function:

SUMMING WORD:
Word: -14
As Binary: 11111111111111111111111111110010
First 8 bits: 00101110

Second 8 bits: 10110001

Third 8 bits: 01000001

Fourth 8 bits: 11110010

I'm assuming it has something to do with the following statement: result = (*mem << 24) | ( *(mem + 1) << 16 ) | ( *(mem + 2) << 8 ) | ( *(mem + 3) );

I just cannot for the life of me figure out what it is! Thanks, all!

I would say your guess about the line is correct.

If you closely look at (*mem << 24) you'll notice that *mem is a char. So another type as in your 1st conversion.

I think this question might enlighten the situation.