Assigning Float Pointers in C [closed]

Answer 1

Keep in mind that:
A pointer is a variable that contains memory address. Other words, content of a pointer is memory address. To utilize the address, you have to request the system reserve it for you via malloc, calloc...

Now let's examine your code:
- Third line: float *x; --> you declares a pointer x pointing to a memory address which will be used to store (some) float number(s). However the address is not allocated yet so it would be anywhere in your system memory and certainly is not reserved for you only.
- Fourth line: *x = *k; --> you access a memory allocation that hasn't been allocated --> a running error. If you are lucky (there is no program access this memory), you can get value of k.

What you should do here is to allocate a memory reserved for x by calling malloc, calloc, ...

If k points to only 1 int number, your code should be:

float *program(const int *k)
{
   float *x;
   x = (float *)malloc(sizeof(float));
   *x = *k;
   return x;
}

And if k points to an arry of int numbers, try to figure out by yourself :)

Answer 2

Here's what your code is doing:

float * program(const int *k)
{
    // declare a pointer to a float, but don't initialize it,
    // so it is not actually pointing anywhere specific yet.
    float *x; 
    // Put the value pointed at by k into the location pointed at by x
    // But wait - we don't know where x is pointing, so this is BAD!
    *x = *k;
    return x;
}

And that is why your compiler is complaining.

Answer 3

It looks as if you're making a cast into a function, or achieving a cast via a function.

The compiler is correct that x is not initialized, so assigning to *x leads to undefined behaviour (and the compiler warning you are getting). This code might be what you want:

const float *program(const int *k)
{
    const float *x = (float *)k;
    return x;
}

You need the cast — unless you are compiling with way, way, way too many warnings disabled. Note that this is still giving you undefined behaviour, but it is a somewhat different form of undefined behaviour — with most systems, this code will reinterpret the int pointer as a float pointer and you'll get more or less sane results. With the uninitialized variable, you simply cannot tell what will happen; it is much worse to dereference an uninitialized pointer.