C - Store float to char array and reverse

Supposing that sizeof(float) is 4, you can copy the representation of the value of a float variable into a char array via memcpy:

#include <string.h>

void do_something(float f) {
    char bytes[4];
    memcpy(bytes, &f, 4);
    // ...
}

You can reverse that operation (that is, copy the representation back) by calling memcpy() again, with the first two arguments reversed. In between, you can manipulate the bytes -- for example, to reverse them -- but in that case, the language does not speak to the float interpretation of the resulting byte sequence.

You can use memcpy, but it is good to include a _Static_assert to check the sizes:

#include <stdio.h>
#include <string.h>

int main(void)
{
    float f = 10./7;
    char  bytes[4];

    // Check that float is the same size as the array we provide.
    _Static_assert(sizeof f == sizeof bytes, "float mus be four bytes.");

    // Copy bytes from the float to the array.
    memcpy(bytes, &f, sizeof bytes);

    // Show the bytes.
    for (size_t i = 0; i < sizeof bytes; ++i)
        printf("Byte %zu is 0x%02x.\n", i, (unsigned char) bytes[i]);

    // Copy the bytes from the array to another float.
    float g;
    memcpy(&g, bytes, sizeof g);

    // Show the resulting float.
    printf("g = %g.\n", g);
}

• To convert float to char array sprintf
• To convert char array to float atof

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char array[10];
    float val;

    sprintf(array, "%f", 3.123);
    val = atof(array);

    printf("%s\n%f", array, val);

    return 0;
}

Output

3.123000
3.123000

memcpy is a built-in function requiring the header "string.h". Depending on your application scenario, if you want to avoid the use of memcpy plus your char array is 4-byte aligned, here is my preferred way based on static casting in gcc-like compilers.

Copy amount (float) to array (char*)

float amount  = 0.01;
char  array[4] __attribute__((aligned(4)));
*((float *)array) = amount; 

Copy bytes (char*) to f (float)

float f;
char bytes[4] __attribute__((aligned(4)));
f =  *((float *) bytes);

Alternatively, here is one more way that I believe will work under any compilers, regardless of byte alignment:

First, define a dummy struct with four bytes (a float takes four bytes. or alternatively, use sizeof(float) in place of 4).

typedef struct {char fourBytes[4]; } FourBytes ; 

Use it as follows:

float amount     = 0.01;
char  array[4]  ;

// copy from amount to array
*((FourBytes *)array) = *((FourBytes *) (&amount));

// copy from array to amount
 *((FourBytes *) (&amount)) = *((FourBytes *)array) ;

From a functional perspective, a third alternative may be just to use a union structure:

union DATA
{
    float f;
    char  array[4];
}; // array is forced to 4-byte aligned

Use it as follows:

union DATA data1;
union DATA data2;

// copy data between the two
data1.f = data2.f