C Converting a struct to an array of bytes and back again

How about memcpy(ptrToAllocedMemory, &structOnStack, sizeof(structOnStack));?

Too convert a struct to an array of bytes ...

Simple assigned via a union. The members of foo will be copied with the assignment, perhaps any padding too. @Eric Postpischil

struct foo {
  int x;
  float y;
} typedef foo;

foo data_as_foo;

union x_foo {
  foo bar;
  unsigned char array_o_bytes[sizeof foo];
} x;

x.bar = data_as_foo;

// Do something with x.array_o_bytes
for (unsigned i = 0; i < sizeof x.array_o_bytes; i++) {
  printf("%2X ", x.array_o_bytes[i]);
}

An assignment is not even needed.

union x_foo = { .bar = data_as_foo );

What is important about return trip for bytes without alignment to foo is to use memcpy().

foo bytes_to_foo(const unsigned char *data) {
  foo y;
  memcpy(&y, data, sizeof y);
  return y;
}

If the bytes are aligned, as a member of union x_foo, than an assignment is sufficient.

union x_foo data_as_bytes;
// data_as_bytes.array_o_bytes populated somehow

foo data_as_foo = x_foo data_as_bytes.bar;

You can simply make a pointer to the address, cast it and handle it from there.

A full code snipping demonstrating what you asked:

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

struct foo
{
  int x;
  float y;
} typedef foo;

int main () {
        char *mem = malloc(1000); // preallocated memory as requested
        foo bar; // initial struct
        bar.x = 10; // initialize struct
        bar.y = 12;

        char *ptr =(char*)(&bar); //cast a char ptr to bar's address
        memcpy(mem, ptr, sizeof(foo)); // copy it over

        foo *result = (foo *)(mem); // cast the memory to a pointer to foo
        printf("%d, %f\n", result->x,result->y); // and it works!

        return 0;
}

If you wanted to cast the pointer and copy it in one line, you could also do

memcpy(mem,(char*)(&bar), sizeof(foo));

For the same effect.

All variables and struct in C are stored in memory, and memory is already array of bytes.

So, in contrast to Java or C#, you do not need to do any additional transformation:

// to get struct's bytes just convert to pointer
struct foo tmp;
unsigned char* byte_array = (unsigned char*)&tmp;

// from bytes to struct
_Alignas(struct foo) unsigned char byte_array2[sizeof(struct foo)];
struct foo* tmp2 = (struct foo*)byte_array2;

as people are pointing in comments - conversion from array to struct could lead to UB on some platforms, so its better to avoid it unless you allocated properly aligned block