Beim Überlesen scheint mir die folgende Antwort einleuchtend, aber wenn ich mit Bleistift und Papier nacheenk, klappt es dann doch nicht.
vielleicht korrigiert jemand mein lautes Denken?

char * buffer;
double v = * reinterpret_cast<double*> ( buffer );

1. "* buffer" zeigt auf die SPeicherstelle, die den ersten char ( = Byte) von buffer enthält und das wäre buffer [0]? ALso sind de Ausdrücke * buffer und buffer[0] identisch ?

2. wenn buffer z.B mit adresse 4711 beginnend gespeichert ist, dann kann ich mir die HAusnummer von buffer so merken: Die Varible bp enthält die Adressse, an der ein char-array gespeichert ist, also sage ich das auch dem Leser, resp compiler
   [/cpp]char * bp;

oder besser?

char* bp;

(oben hieß es eben "buffer")

3)Wie sieht es mit dem SPeicherplatz aus, wenn das array unterschiedlich lang ist?. Es beginnt bei 4711: mindest ein byte brauche ich für das Ende-Kennzeichen  '\0'. WIeviel Paltz wird nun reserviert, wenn ich nur so deklariere vie im Beispiel? Bei

char buffer[5];

würden 4711 bis incl. 4715 reserviert. Ich hätte Platz für 4 "NutzZeichen".

4)Zur zweiten - der Wandel-Zeile: ich habe das Beispiel mit "int" ( 4Byte) probiert,

char * buffer;
int v = * reinterpret_cast<ins*> ( buffer );[cpp] und glaube auch diese etwa verstanden zu haben:
in buffer [0] bis buffer[3] steht nach dem seriellen Einlesen das binäre Abbild einer INT.
Ohne das reinterpret_cast<ins>* würde der compiler, um v bestimmen zu können, versuchen 4Byte beginnend ab Adresse 4711 ( =buffer[0] ) zu lesen und v zuzuweisen: In seinem "Adressbuch" hat er aber notiert, daß dort char stehen, und schmeisst einen Fehler.
ALso sagen wir ihm durch das reinterpret: "lieber Compiler, tu mal so, als stünde in Deinem Adressbuch, daß ab 4711 ne Int steht" ??

und irgendwo muss was schief sein, da ich den umgekehrten Weg nicht gebacken bekomme.

Danke für Eure Geduld, und daß sich eventuell meiner erbarmt
Hanns

p.s.
Ich hab mir scheon ein paarmal mein passwort schicken lassen, aber ich kann mich nicht einloggen??
Der umgekehrte Weg, aus ner int einen String zu machen, müsste dann so gehen:

Caipi
</offtopic>

@Caipi: Tut mir leid, aber ich bin da irtgendwie vernagelt, und würde es doch gern verstehen.

HannsW

char buffer[5];
char * cP = buffer;
int * iP = reinterpret_cast<int*>(buffer);
*iP = 12345;
buffer[4]=0; // terminating 0 anhängen für alle fälle
             // macht zwar wenig sinn denn wahrscheinlich ist schon irgendwo eine 0
for ( int i = 0; i < 4; ++i ) // int als char ausgeben 
   cout << buffer[i] << endl;

for ( int i = 0; i < 4; ++i ) // int als asciiwerte ausgeben 
   cout << static_cast<int>(buffer[i]) << endl;

// andere Richtung
strcpy(cP, "1234");
cout << *iP << endl;

Kurt
edit: lots of typos

Was genau ist denn deine Absicht? Sowas macht man manchmal um Daten zu serialisieren, wobei das auch nicht unbedingt ne gute Möglichkeit ist, da es so sehr Plattformabhängig ist.

Wenn wir von 4Byte ausgehen für nen int, dann schreibst du mit iP = 12345; was in den Speicher das so aussehen könnte 00000000000000000011000000111001, wenn du dir das nun als einen String, oder einzelne Chars ausgeben lässt bekommst du da aber was ganz anderes raus als 12345 oder was das da auch nur entfernt hin kommt.

Was genau ist denn deine Absicht? Sowas macht man manchmal um Daten zu serialisieren, wobei das auch nicht unbedingt ne gute Möglichkeit ist, da es so sehr Plattformabhängig ist.

Hat er doch schon gesagt dass die Daten von einer seriellen Schnittstelle kommen und in einem char-Buffer liegen.

int * iP = reinterpret_cast<int*>(buffer);
*iP = nWert;

Könnste da noch mal ein paar worte sagen?
oder soll ichs nochmal versuchen?
Hanns

*iP = nWert;

-An die SPeicherstelle, deren Nummer in iP steht, soll nWert eingetragen werden.
( Liebling, Dein Essen steht im Kochbuch auf Seite 13 !?)
-"normal" waäre dann dieses

int i;
int * iP = i ;

- da wir iP auf eine Speicherstelle lassen, an der ein char-Array steht, kommt der cast ins SPiel ?

So etwa?

War grad mal weg, und sehe eben die anderen Post.
Was ich machen will?
Klassen schreiben, um auf ein Datenbanksystem zu greifen zu können.
Die Api verlangt die Daten in einem char-Array, in dem für int's 4Bytre vorgesehen sind.
UNd in diees Array müssen eben die richtigen "strings" stehen.
Für "bool" war das nicht so schwierig:

bool myClass::Boolean{
      return m_dataBuf[ anDerStelle] == chr(0); 
}

@User--Genau das möchte ich, und nicht etwa die Zahl als String auf den Drucker geben

Das mit dem "in Ordnung bringen" klappt leider nicht mehr, da ich diese post als nicht registriert auch nciht mehr editieren kann. Sorry

Du musst das nur tun um einen Block von Bytes anderst zu behandeln, in deinem Fall eben 4Chars als einen Integer. Du kannst das auch mit ner union machen:

union konverter
{
  char alsChars[ 4 ];
  int  alsInt;
} myKonverter;

myKonverter.alsChars = "1234"; // Zugriff in Form von Char Array auf den Speicher
myKonverter.alsInt = 12345;    // Zugriff als Integer auf den Speicher

Was ich machen will?
Klassen schreiben, um auf ein Datenbanksystem zu greifen zu können.
Die Api verlangt die Daten in einem char-Array, in dem für int's 4Bytre vorgesehen sind.
UNd in diees Array müssen eben die richtigen "strings" stehen.

Ich versuch einmal zu erklären.
Also Dein Datenbanksysten hat wahrscheinlich irgendeine Funktion mit der du beliebige Daten Eingeben kannst. Damit das API nicht zu aufwendig wird gibt es wahrscheinlich nur eine ( oder wenige ) funktionen zum schreiben in die datenbank.
Du Sagst wahrscheinlich nur irgendwas wie Schreibe Daten in den Record soundso Feld sowieso. Die Datenbank weiss ja schon welchen Datentyp das Feld hat. Daher haben sich die Entwickler darauf geeinigt der Funktion die daten als array von chars zu übergeben. Das hat überhaupt nichts mit 0-terminierten strings zu tun. Sie wollen einfach nur mit einer einzigen funktion auskommen.
Für dich bedeutet das dass du der Funktion einfach einen Pointer auf deine Daten übergeben musst den du immer ( egal welchen DatenTyp das Feld hat ) in einen char * casten musst.

Ich stelle mir das so vor:

void set_data( long int ID, const char * feld, const char * data ); // möglicher prototyp der Eingabefunktion

Beispiel:

char * name = "ein string";
   set_data( 12345, "name", name ); // die datenbank weiss das feld name ist ein string typ passt kein cast
   short int haus_nr = 123;
   set_data( 12345, "Nr", reinterpret_cast<char*>(&hausnummer) ); // die datenbank weiss das feld Nr ist ein short also casten wir halt
   int postleizahl = 45123;
   set_data( 12345, "Plz", reinterpret_cast<char*>(&postleizahl) ); // die datenbank weiss das feld Plz ist ein int also casten wir halt

Umgekehrt wirds wahrscheinlich genauso funktionieren

void get_data( long int ID, const char * feld, char * data ); // möglicher prototyp der Ausgabefunktion
                                                               // data kann nicht const sein den die funktion verändert den wert

Beispiel: lesen aus der DB

char name[255];
   get_data( 12345, "name", name ); // die DB füllt name
   short int haus_nr;
   get_data( 12345, "Nr", reinterpret_cast<char*>(&hausnummer) ); // die DB füllt haus_nr   
   int postleizahl;
   set_data( 12345, "Plz", reinterpret_cast<char*>(&postleizahl) ); // die DB füllt postleitzahl
   // gelesene daten ausgeben
   cout << "Name=" << name << endl;
   cout << "Nr=" << haus_nr << endl;
   cout << "Plz=" << postleizahl << endl;

Langer Rede kurzer Sinn. Die datenbank erwartet die daten immer als char * damit mit einer einzigen Funktion alle möglichen Datentypen abgedeckt werden können.
Wie die Daten interpretiert weden müssen ist in der DB festgelegt.

Kurt

PS:Bitte nicht schlagen wenn das ganze mit deinem Problem nichts zu tun hat.

Dann aber noch ne design Frage:
In meiner TOP-Klasse habe ich nun die Methoden setInteger und getIntger, die ich nun in 2 Varianten ausführen kann.

void btrieve::setInteger ( int nStart, int  nWert){
        union konverter
        {
                char alsChars [ APP_INTEGER_LEN + 1 ];   // 4 +1 Byte
                int  alsInt;
        } myKonverter;
        myKonverter.alsInt = nWert ;    // Zugriff als Integer auf den Speicher

        //und in den DatenPuffer schreiben
        for ( int i = 0; i < APP_INTEGER_LEN ; ++i ){
                m_dataBuf [ i + nStart ] =  myKonverter.alsChars[i];
        }
}

oder variante 2

void btrieve::setInteger ( int nStart, int  nWert){
        char buffer[ APP_INTEGER_LEN + 1];
        int * iP = reinterpret_cast<int*>(buffer);
        *iP = nWert;
        for ( int i = 0; i < APP_INTEGER_LEN; ++i ){ 
                m_dataBuf [ i + nStart ] =  buffer[i];
        }
}

Was davon ist denn "besserer" Stil, resp schneller?

Wobei ich bei der Variante 1 ( Union ) die Union bereits als Klassen-Union deklarieren würde? Sie müsste dann nicht bei jedem get-/set- Aufruf erzeugt und danach entsorgt werden. etwa so?

// btrieve.hh
//...
        union konverter
        {
                char alsChars [ APP_INTEGER_LEN + 1 ];   // 4 +1 Byte
                int  alsInt;
        } myKonverter;
//...
//btrieve.cc
...
void btrieve::setInteger ( int nStart, int  nWert){
        myKonverter.alsInt = nWert ;    // Zugriff als Integer auf den Speicher

        //und in den DatenPuffer schreiben
        for ( int i = 0; i < APP_INTEGER_LEN ; ++i ){
                m_dataBuf [ i + nStart ] =  myKonverter.alsChars[i];
        }

int  btrieve::getInteger ( int nStart){
        for ( int i = nStart; i < nStart + APP_INTEGER_LEN ; i++){
                myKonverter.alsChars [ i -nStart ] = m_dataBuf [i ];
        }
   return  myKonverter.alsInt;
}

Ich hab nun ne Klasse btrieve, in der ich u.a die Umwandlung in und zu ints vornehme ( void btrieve::setInteger(int nStart, int nWert) und int btrieve::getInteger ( nstart) )

davon baue ich nir dann z.B. ne btrieve::aliasPerson() in der ich dann z.B

int aliasPerson::hausnummer ( ) {
   return getInteger( APP_HAUSNUMMERN_START);
}

definiere. und in der ANwendung dann eben

aliasPerson person = aliasPerson(....);
   //open
   //suche und so
   cout << "hausnummer " << person.hausnummer << endl;

void btrieve::setInteger ( int nStart, int  nWert){ // nehme an nStart ist ein offset in byte
    memcpy((m_dataBuf + nStart), &nWert, sizeof(nWert));
}

int  btrieve::getInteger ( int nStart){
    int ret;
    memcpy( &ret, (m_dataBuf + nStart), sizeof(ret));
    return  ret;
}

Das ist wahrscheinlich die performanteste lösung. Ist zwar kein schönes C++ aber wenn man C-API's verwenden muss dann ist das meiner meinung nach erlaubt.
Kurt

void btrieve::setInteger ( int nStart , int nWert){ // nehme an nStart ist ein offset in byte   == JA 

    memcpy((m_dataBuf + nStart), &nWert, sizeof(nWert));
    // neige ich dazu so zu schreiben:
    memcpy((m_dataBuf + nStart), &nWert, APP_INTEGER_LEN) ;
    // oder eindef aus der api.hh nehmen
    memcpy((m_dataBuf + nStart), &nWert, BTI_INT;
}

Obwohl es dann doch sicherer wäre, den parameter-Typ zu "api-def"fen?

void btrieve::setInteger ( int nStart, BTI_INT nWert ){ // aus der api.hh
  //...
}

Deine Lösung könnte ich dann erweitern, und sie gleich für alle Arten von Zahlen
verwenden:

void btrieve::setZahl ( int nStart,int nWert,int nBytes ){
memcpy((m_dataBuf + nStart), &nWert, nBytes );
}

// und in alisaPerson
void aliasPerson::hausnummer (int nWert ) {
   setZahl( APP_HAUSNUMMERN_START, nWert, APP_INTEGER_LEN);
}
}

Danke für die Hilfe
Hanns

typedef  __int32 bt_int;  // keine Ahnung ob es __int32 bei deinem compiler gibt
void btrieve::setInteger ( int nStart , bt_int nWert){ 
  memcpy((m_dataBuf + nStart), &nWert, sizeof(nWert));
}

Kurt

void btrieve::setInteger ( int nStart , int nWert){ 
    memcpy((m_dataBuf + nStart), &nWert,sizeof( BTI_INT));
}

Wobei BTI_INT aus den Headern der Api kommt, und dort auch ne Menge #ifdef ARCHITEKTUR UND BETRIEBSYSTEM existieren, die einem diese Arbeit abnehmen.

#define LINUX

reicht.
Aber Danke nochmals für den Hinweis
Hanns