Kennt wer eine Seite wo man nachlesen kann, wie man am besten
double nach char* umwandelt, und umgekehrt, damit ich das ganze im
binär-format abspeichern kann?
Das würde nämlich jede Menge Ladezeit sparen.

Danke im Vorraus.
Das Problem ist nur das sizeof(double) ständig schwankt, geringer datenverlust
würde mich nicht stören (zB 64bit double als 32bit abspeichern, und dann wieder als 32bit laden)

Kennt wer eine Seite wo man nachlesen kann, wie man am besten
double nach char* umwandelt, und umgekehrt, damit ich das ganze im
binär-format abspeichern kann?

Versteh ich nicht. Du kannst jeden beliebigen Datentyp im Binärformat abspeichern, dazu bedarf es keiner Zeichenkette o.Ä..

Das Problem ist nur das sizeof(double) ständig schwankt, geringer datenverlust
würde mich nicht stören (zB 64bit double als 32bit abspeichern, und dann wieder als 32bit laden)

Meinst du, die Größe eines doubles ändert sich auf einer anderen Platform? Das ist kein Problem. Entweder du bedienst dich an den platformunabhängigen Datentypen aus der Boost-Library, oder bastelst dir z.B. deinen platformunabhängigen Datentyp selber, wie hier als Beispiel näher gebracht (es handelt sich um einen Integer, lässt sich aber problemlos als Templateklasse implementieren):

#include <iostream>
using namespace std;

typedef unsigned char My32BitInteger[4];

class MyInteger
{
    private:
        My32BitInteger myInt;

    public:
        // Konvertierungsoperator
      operator int();
    // Standardkonstruktor
    MyInteger()
    {
        cout << "Standardkonstruktor" << endl;
        myInt[0] = 0;
        myInt[1] = 0;
        myInt[2] = 0;
        myInt[3] = 0;
    }

    // Konvertierungskonstruktor
    MyInteger( int i )
    {
        cout << "Konvertierungskonstruktor" << endl;
        myInt[0] = *( reinterpret_cast <char*> (&i)   );
        myInt[1] = *( reinterpret_cast <char*> (&i)+1 );
        myInt[2] = *( reinterpret_cast <char*> (&i)+2 );
        myInt[3] = *( reinterpret_cast <char*> (&i)+3 );
    }
};

// Konvertierungsoperator
MyInteger:: operator int()
{
     cout << "Konvertierungsoperator " << endl;
    return     *(reinterpret_cast <unsigned*> (myInt));
}

int main()
{
    // Konvertierungskonstruktor
    MyInteger my_int( 77777777 );
    cout << my_int << endl;
    // Standardkonstruktor
     MyInteger my_integer;
    // Konvertierungsoperator
      int i = my_integer;
    cout << i << endl;
    my_integer = my_int;
    cout << my_integer << endl;
    getchar ();
}

In dem Beispiel ist der Integer also auf jeder Platform 32 Bit groß.

ich weiss schon, das man sowas in etwa so schreiben würde, wie du es aufgezeigt hast, mein problem ist eher, das ich nicht genau weiss, wie ich die konvertierungsoperatoren schreiben soll, du machst ja auch die annahme das
sizeof(int) == 4

Mir reichts eigentlich auch, wenn die dateien nur auf der selben
Platform lesbar sind.

und dann geht das ja auch ziemlich einfach mit sizeof() und rumcasten.

ich werde wohl den traum von :
" schreibe double in bin-file auf 32bit-windows, und
lese die datei in 64bit-linux" verwerfen.

Wieso verwerfen? Wozu halten sich wohl (sogut wie) alle an den IEEE 754 Standard?
Ist in C++ IEEE 754 nicht sogar vorgeschrieben (double und float)?