Typecasting Pointers in C

Question

I'm new to C, and I'm writing a very basic function that takes an integer pointer as a parameter. Inside the function, a float pointer must be created. This function must assign the value of the integer pointer to the float and then return the float. Here's my code at the moment:

float * function(const int *x)
{
    float *p = (float*)x;
    return p;
}

But this results in an error that reads as such when run: "free(): invalid pointer: 0x00007fffc0e6b734". Suffice it to say, I'm very confused. Any insights you can offer would be much appreciated!

Answer 1

Being new to C, are you familiar with the scope of variables? (Part of) the short version of variable scope is that if you don't do a little something extra, a variable created in a function only exists inside that function. Why that's important to you: if you return a pointer to a variable that you created inside a function (without doing that little something extra) that pointer will point to an area of memory that may or may not contain the value that you assigned to it. One way to do what you want is this:

float *makefloat(int *x) {

//  static keyword tells C to keep this variable after function exits
    static float f;

//  the next statement working from right to left does the following
//  get value of pointer to int (x) by dereferencing:   *x
//  change that int value to a float with a cast:       (float)
//  assign that value to the static float we created:   f =
    f = (float) *x; 
//  make pointer to float from static variable:         &f
    return &f;
}

In general I seem to see more functions that accept a pointer to the variable that is to be modified, then in that function the new value is created and assigned to the area in memory referenced by the pointer. Because that area of memory exists outside of the scope of the function, there is no need to worry as much about scope and static variables. Another cool thing about static variables is that the next time the function is called, the static variable has the same value it did when the function last exited. Explained on Wikipedia.

Good explanation of * and &: Pointers in C: when to use the ampersand and the asterisk

Answer 2

Your function only performs a pointer conversion. A function call of the form

q = function(p); /* p is a "const int *" pointer,
                    q is assignment comaptible with "float *". */

can be replaced by the expression:

q = (float *) p;

by itself, this doesn't do any harm. The problem is elsewhere in your program.

Note that most type punning, like accessing an object of type int using an expression of type float via pointers, is undefined behavior in the C language. This isn't going on in the example code, but things are headed in that direction; the pointer is probably being prepared for carrying out type punning.

Consider that int and float don't necessarily even have the same size; and that is not the only consideration. In code like this:

int i = 42;
/* now treat i as a float and modify it sneakily */
*((float *) &i) = 3.14;

printf("i = %d\n", i);

the output of the printf can still be 42. The optimizing compiler can put i into a machine register, whereas the sneaky assignment might be performed on the memory location that serves as the "backing storage" for i, and so i appears unchanged since the printf call uses the register-cached copies. The compiler is not required to consider that a modification of an object designated by the type float might affect the value of an object of type i (even if they otherwise have the same size, so there is no collateral damage done by the assignment, like overwriting other objects).

In the real world, sometimes it is necessary to write a code that manipulates floating-point objects as if they were integers: typically unsigned int integers, to gain access to the bitwise representation of the float. When this is done, you have to use unions, or perhaps compiler-specific features, like GCC's -fno-strict-aliasing option which causes the compiler to optimize more cautiously in the face of type punning. in that kind of code, you make sure that the assumptions are all warranted about the sizes of types and such, with #ifdef-s for different platforms, perhaps based on values pulled from running configured scripts to detect platform features.

Needless to say, this is not a good way to be learning C at a beginner level.