Here is one solution using memcpy function:

double d = 0;
unsigned char buf[sizeof d] = {0};

memcpy(&d, buf, sizeof d);

Note that a solution like:

d = *((double *) buf);

shoud be avoided. This is undefined behavior because it potentially violates alignment and aliasing rules.

Here's a rather unsafe way to do it:

double d = 0.123;
char *byteArray = (char*)&d;

// we now have our 8 bytes

double final = *((double*)byteArray);
std::cout << final; // or whatever

Or you could use a reinterpret_cast:

double d = 0.123;
char* byteArray = reinterpret_cast<char*>(&d);

// we now have our 8 bytes

double final = *reinterpret_cast<double*>(byteArray);
std::cout << final; // or whatever

This is really wrong you are saving pointers to address that would be out of scope (a and b), this would cause invalid memory access (would work as you expected OR would not).

You are declaring a vector of pointer (std::vector<unsigned char*>) not a vector of unsigned char (std::vector<unsigned char>).

According to the output of this sample, it appear as if GCC (version 4.9.0) it reusing the same memory for variables a and b in the loop OR extracted away the variables of the loop. Because it prints only two different address of the pointer storage in the vector.

#include <vector>
#include <iostream>

int main() {
    std::vector<unsigned char*> v;

    for (int i = 0; i < 5; i++) {

        double a = 3.14 + i;
        double b = 4.44 + i;

        v.push_back((unsigned char*)&a);
        v.push_back((unsigned char*)&b);
    }

    for (int i = 0; i < v.size(); i++) {
        std::cout << std::hex << ((double*)v.at(i)) << std::dec << std::endl;
        std::cout << *((double*)v.at(i)) << std::endl;
    }
}

Output:

0x22fec0  -> Address 1
7.14
0x22fec8  -> Address 2
8.44
0x22fec0  -> Address 1
7.14
0x22fec8  -> Address 2
8.44
0x22fec0  -> Address 1
7.14
0x22fec8  -> Address 2
8.44
0x22fec0  -> Address 1
7.14
0x22fec8  -> Address 2
8.44
0x22fec0  -> Address 1
7.14
0x22fec8  -> Address 2
8.44

Assuming p->strk is an array of bytes:

This doesn't work:

*pdest = (double)p->stk[stkpos];

Because you're only reading a single byte and assigning that value to a double.

This doesn't work:

*pdest = (double)((double*)&p->stk[stkpos]);

Because of the outer cast. The first part, casing &p->stk[stkpos] to a double * will in fact give you a pointer to a double that starts at the address of &p->stk[stkpos], but then you cast the value of that pointer, i.e. a memory address (not what it points to) to a double which doesn't make sense.

What you were probably trying to do what this:

*pdest = *((double*)&p->stk[stkpos]);

This takes the address of p->stk[stkpos], treats it as a pointer to a double, and dereferences the address to read a double.

There's still a problem with this, however. Such a conversion violates strict aliasing. And even if strict aliasing was disabled, you might end up with a misaligned memory access.

The proper way to do this is to use memcpy. That is guaranteed to work as expected.

Here's a way to do what you want that won't break if you're on a system with a different endianness from the one you're on now:

byte* floatToByteArray(float f) {
    byte* ret = malloc(4 * sizeof(byte));
    unsigned int asInt = *((int*)&f);

    int i;
    for (i = 0; i < 4; i++) {
        ret[i] = (asInt >> 8 * i) & 0xFF;
    }

    return ret;
}

You can see it in action here: http://ideone.com/umY1bB

The issue with the above answers is that they rely on the underlying representation of floats: C makes no guarantee that the most significant byte will be "first" in memory. The standard allows the underlying system to implement floats however it feels like -- so if you test your code on a system with a particular kind of endianness (byte order for numeric types in memory), it will stop working depending on the kind of processor you're running it on.

That's a really nasty, hard-to-fix bug and you should avoid it if at all possible.

The main issue with your program is the shifting of a smaller data type when you read. You have this in two places (shown together here for clarity, despite being out of context):

outp += ((uint8_t)(*begin) << (i * 8));
outp += ((*begin) << (i << 3));

In both these cases, the iterator begin references an underlying type of int8_t. Not only is this a signed type, but you're placing trust in the compiler to promote the type to a large enough integer. I actually ran into a similar issue some years ago.

See here: Undefined high-order of uint64_t while shifting and masking 32-bit values

The fix is to cast to the correct size before shifting:

outp += (((value_t)(uint8_t)*begin) << (i * 8));
outp += (((value_t)(uint8_t)*begin) << (i << 3));

I would also like to suggest that you avoid using constructs like i << 3 instead of i * 8. There is simply no need to try and be clever. The compiler will do the right thing, and you're just making the code harder to read. It also lacks consistency, since you're using both forms in the same function.