Getting the distance b/w float and its neighbor - c

Question

This is my function that takes in the bits of a float, and returns the distance between the next float and the given float. In it, I have assumed the float is 32 bits. My process was to extract the mantissa and exponent, increment the mantissa, increment the exponent if it overflows, reconstruct the value and subtract the distance between them.
I have a feeling I may be overcomplicating things, and the function doesn't seem to be making use of the bitwise operators used correctly, even though I have used an algorithm similar to this before. What is going wrong here? It seems straightforward enough?
unsigned int get_distance(unsigned int bitnumber)
{
unsigned int mantissa = 0xff;
for (int i = 0; i < 24; i++) {
if (((1 << i) & bitnumber) != 0) mantissa = mantissa | 1 << i;
}
mantissa = mantissa++; // increment the mantissa
unsigned int exponent = 0xff;
for (int i = 24; i < 31; i++) {
if (((1 << i) & floatbits) != 0) exponent = exponent | 1 << i;
}
if (mantissa != mantissa) exponent++; // if it overflows, increment the exponent too.
// create complete bit pattern
unsigned int final = 0xff;
for (int i = 0; i < 32; i++) {
if (i < 24) {
if (((1 << i) & mantissa) != 0) final = final | 1 << i;
}
if (i >= 24 && i < 31) {
if (((1 << i) & exponent) != 0) final = final | 1 << i;
}
if (i == 32) {
if (((1 << i) & bitnumber) != 0) final = final | 1 << i;
}
}
// get difference b/w original float and new float
unsigned int result = final - bitnumber;
return result;
}

Answer 1

First off, you are unnecessarily complicating the extraction of the various fields (and, you're doing so incorrectly). A much easier way to do this is:
unsigned int exponent = (bitnumber >> 23) & ((1 << 8) - 1);
unsigned int mantissa = bitnumber & ((1 << 23) - 1);
Basically, you shift bitnumber left until the LSB of your desired field is bit 0, and then bitwise-and out just the bits you want. The expression ((1 << N) - 1) is a mask consisting of N 1s in the lowest bits.
Second, the line mantissa = mantissa++; is actually undefined behavior, since the post-increment and assignment will both try to assign a value to mantissa. Instead, you just want mantissa++.
Next, the check for overflow will never pass, as mantissa != mantissa will always be false. Instead, you want to check if bit 23 or higher is set, which can be done with mantissa >= (1 << 23). I'd also recommend grouping this statement with the aforementioned increment, so you have
mantissa++;
if (mantissa >= (1 << 23))
exponent++;
Finally, reconstructing the new value is as simple as:
unsigned int final = (exponent << 23) | mantissa;
Note, however, that if exponent is too large, this will result in a different float than you expect (namely, a negative one). There are also a few other boundary cases regarding infinity/NaN and unnormalized numbers, but more than likely you won't run into them.
To actually use this, you'll need to do some pointer conversion, like this:
float value = 1.0f; // for example
unsigned int *up = (unsigned int *)&value; // NOTE: this might trigger undefined behavior
unsigned int next = next_value(*up); // next_value is a better name for your function than get_distance
float *fp = (float *)&next; // again, this may be UB
float difference = *fp - value; // this is what you want