Frage zu static_cast

icarus2

cout << static_cast<long>(*dp2) - static_cast<long>(*dp1) << endl; // Etwas weniger Ärger

Braucht da aber eigentlich kein cast.

*Edit
omg - mal wieder viel zu langsam -.-

fujittsu

Da habe ich woll ein wenig dazu geschrieben. Es geht darum festzustellen wieviel
Byte die beiden Zeiger auseinander liegen.

Das dürften nach meinen bescheiden Kenntnissen 8 Byte sein. Da eine double Variable ja 8 Byte belegt. Nun wollte ich das durch diese Rechnung verdeutlich.

mfg
Fujittsu

padreigh

&(d[1])-&(d[0]) ?

dot

fujittsu schrieb:

Es geht darum festzustellen wieviel
Byte die beiden Zeiger auseinander liegen.

(dp2 - dp1) * sizeof(double)

!?

fujittsu

Danke schön für eure Hilfe! Ich muss mir die Sache nochmal durch den Kopf
gehen lassen.

mfg
Fujittsu

dot schrieb:

!?

‽

krümelkacker

fujittsu schrieb:

double d[10] = {1,2,3,4,5,6,7,8,9,20};

double *dp1 = d;
double *dp2;

dp2 = dp1 + 1;

cout << static_cast<long>(dp2) - static_cast<long>(dp1) << endl;

cout << (dp2-dp1) << endl;

Eine Adresse ist eine Zahl. Von älteren Versionen des GCC-Compilers wurde static_cast akzeptiert, was jetzt nicht mehr der Fall ist. Sorry, mein Fehler, dass ich die Stelle nicht aktualisiert habe. reinterpret_cast verzichtet auf jegliche Typ-Verträglichkeitsprüfung und ist hier angebracht - oder man nimmt den alten C-Cast, der aber nicht mehr empfohlen wird. Ohne Cast geht es aber nicht, weil ja gerade gezeigt werden soll, dass die Adressen um 8 Byte auseinanderliegen, wenn nur ein Element im Feld weitergegangen wird.

cout << dp2-dp1 << endl;                  // ergibt 1

   cout <<  reinterpret_cast<long>(dp2)      // C++, ergibt 8
      - reinterpret_cast<long>(dp1) << endl;

   cout << (long)dp2 - (long)dp1 << endl;    // C-cast, ergibt 8

U. B.

fujittsu

Danke für die Antwort. Da habe ich mir woll doch das richtige Buch gekauft wenn
gleich der Autor antwortet.

mfg
Fujittsu

camper

(dp2 - dp1) * sizeof(*dp1)

oder

reinterpret_cast<char*>(dp2) - reinterpret_cast<char*>(dp1)

Das andere ist... ein bisschen unglücklich.

(dp2 - dp1) * sizeof(*dp1)

zeigt nur, dass man annimmt, dass die Adressen tatsächlich sizeof(double) auseinanderliegen (ist ja eine vernünftige Annahme). Bewiesen wird es dadurch aber nicht. Dazu muss man schon die tatsächlichen Byte-Adressen ermitteln.

camper

Breymann schrieb:

(dp2 - dp1) * sizeof(*dp1)
zeigt nur, dass man annimmt, dass die Adressen tatsächlich sizeof(double) auseinanderliegen (ist ja eine vernünftige Annahme). Bewiesen wird es dadurch aber nicht. Dazu muss man schon die tatsächlichen Byte-Adressen ermitteln.

Beweisen lässt sich durch Code sowieso nichts. Wenn die Annahme nicht zuträfe, wäre das Ergebnis undefiniertes Verhalten.

Wie zeigt man, wieviele Bytes zwischen 2 Adressen liegen? Indem man beide Adressen als Byte-Adresse bestimmt und sie voneinander abzieht. Sowas wie

(dp2-dp1)*sizeof(*dp1)

macht das nicht. Es ist eine blosse Multiplikation, die darüber nix aussagt.

camper

Besserwisser2 schrieb:

Wie zeigt man, wieviele Bytes zwischen 2 Adressen liegen? Indem man beide Adressen als Byte-Adresse bestimmt und sie voneinander abzieht. Sowas wie
(dp2-dp1)*sizeof(*dp1)
macht das nicht. Es ist eine blosse Multiplikation, die darüber nix aussagt.

Ich sehe hier zunächst einmal eine Subtraktion von zwei Zeigern. Das Ergebnis ist wohldefiniert und es besteht ein bekannter (weil so festgelegter) Zusammenhang mit dem Abstand der Objekte ausgedrückt in Bytes. Ich verstehe dein Problem damit nicht.