Adressangaben byteorientiert?

oelsni

1. in c++ sind addressen in der regel 32 bit ergo 0x00112233 (glaube das sind absolute addressen) 16bit wäre relativ zum startpunkt aber glaube c++ macht das nicht mit
2. +1 hieße 1 byte weiter im speicher

oelsni schrieb:

1. in c++ sind addressen in der regel 32 bit ergo 0x00112233 (glaube das sind absolute addressen) 16bit wäre relativ zum startpunkt aber glaube c++ macht das nicht mit

Adressangaben sind unabhängig von der Sprache Es klappt beides, im Prinzip ist es egal, wieviel Bits man angibt. Würde mich aber auch mal interessieren, ob die Adressangaben absolut oder relativ sind.

Zu 2.) thx

Panke

Heißt +1 nicht, dass ich um die Größe eines Integers (der Größe des Typs auf den der Zeiger zeigt) im Speicher weiter gehe?

LordJaxom

oelsni schrieb:

1. in c++ sind addressen in der regel 32 bit ergo 0x00112233 (glaube das sind absolute addressen) 16bit wäre relativ zum startpunkt aber glaube c++ macht das nicht mit

"In C++" ist hier ausserordentlich schlecht gewählt ;). Soweit ich weiss stellt C++ garkeine besonderen Anforderungen an die Adressbreite, und es gibt durchaus noch Plattformen, die mit anderen Busbreiten arbeiten (und dabei denke ich nichtmal an 64-bitter).

2. +1 hieße 1 byte weiter im speicher

Der Adressarithmetik zufolge würde der Ausdruck &probe + 1, da probe ein int ist, sizeof(int) byte weiter im Speicher bedeuten.

Dann müsste also das Erhöhen um ein Byte folgendermaßen ausschauen:
[cpp]&probe += sizeof (bool);

LordJaxom

Nein auch nicht

In diesem Fall würde die Adresse um sizeof(int) * sizeof(bool) erhöht. Du musst schon den Zeigertyp auf einen ein Byte breiten Typ casten, um sowas zu bekommen. Aber warum willst Du das überhaupt, da dürfte in den meisten Fällen Müll rauskommen...

Im Übrigen unterstelle ich, dass das += ein Tippfehler war

char* einByteWeiter = reinterpret_cast<char*>(&probe) + 1;

oelsni

ups +1 int right habe titel gelesen da steht byte orientiert, daher die aussage 1 byte weiter. was das andere angeht, sagte ich ja GLAUBE das das (in dem fall c++/c) nicht mitmacht weis es aber nicht weil selbst bei 16 bit system mit 32 bit adressiert werden kann/muss durch die heutigen großen speicher durch kombination von 2 registern. weis nicht mehr genau ist dann glaube offset:segment oder andersherum (weis auch nicht ob segment die richtige bezeichnung ist). sonst klar aber wo findest heute noch rechner wo ein 16bit adressraum die totale adresse wiederspiegelt?

LordJaxom

oelsni schrieb:

[...] sonst klar aber wo findest heute noch rechner wo ein 16bit adressraum die totale adresse wiederspiegelt?

Ohje, bissi mehr Satzstruktur wäre freundlich

Was Du gerade offenbar meinst kenne ich aus DOS-Zeiten, da habe ich mich mit solchen Interna noch nicht wirklich auseinandergesetzt. Ansonsten gibt es doch noch viele andere Prozessoren, wo C und C++ verwendet werden können, z.B. Mikrocontroller, mit denen man auch schön selbst was basteln kann ;). Ein paar davon haben tatsächlich nur 16 Bit Adressraum.

Achja: Und bei 64 Bit Betriebssystemen ist ein Zeiger 64 Bit breit.

LordJaxom schrieb:

Aber warum willst Du das überhaupt, da dürfte in den meisten Fällen Müll rauskommen...

Ich brauch das garnicht, es ist eine reine Interessenfrage Dass sowas natürlich gefährlich ist, und Access Violations verursachen kann, ist mir klar.

LordJaxom schrieb:

Im Übrigen unterstelle ich, dass das += ein Tippfehler war

Entweder dir kommt es jetzt auf den Sinn der Operation an (würde natürlich keinen Sinn ergeben), oder du meinst die Syntax der Addierung. Mein Compiler (MinGW) schluckt jedenfalls beides: += und =+

Du bist in deinem Codebeispiel von einem char-Typen ausgegangen (einByteWeiter). Was ist jedoch, wenn ich mit einByteWeiter den Inhalt als Integer interpretieren möchte? Dann muss doch folgendes genauso gehen:

int *probe = reinterpret_cast <int*> (0x1234);
int* einByteWeiter = reinterpret_cast <int*> (&probe) + sizeof (char);

Oder soll ich ausgehend von deinem Beispiel den Zeiger von einByteWeiter nach dem Erhöhen wiederrum auf einen Integer umcasten?!

LordJaxom

Genau das letztere musst Du tun - da in Deinem Codebeispiel probe als int widerum um die Größe eines int verschoben würde. Links vom + steht ein int*, weshalb die Größe rechts vom + bewirkt, dass sizeof(char) * sizeof(int) addiert wird. Wenn Du wirklich ein Byte an einer krummen Adresse als int interpretieren willst, musst Du schon übel rumcasten.

Ach okay, dann ist es mir klar geworden Stellt sich nurnoch die Frage, ob nun Adressangaben im Programm relativ oder absolut sind?

oelsni

Sry Gerstern ist mein drecks UMTS mal wieder ausgestiegen (lieber gott verwandle die glasfaserleitungen doch bitte in kupfer will endlich wieder dsl^^)

wollte gestern noch was dazu schreiben

grundlegen schon klar man kann adressieren wie man will auch 24bit / 48bit. Jedoch finde ich perönlich dieses nicht so gut weil der prozi an sich dafür keine optimierten register hat. Klar der compiler erledigt das aber wenn man sich gleich angewöhnt halbe / eifache / doppelte registerbreiten zu nehmen, fällt man mal nicht auf den mund, wenn man sehr hardwarenahe programmierung betreibt.

desweiteren, habe nicht geschaut ob es schon beantwortet wurde, 16bit adressierung ist ein adressraum von 64kb (65535 bytes) alle microcontroller die ich kenne haben mind 1 mb drinnen und können erweitert werden. 16bit adressen sind daher meist/(doch fast immer) relativ (brauchen einen bezugspunkt -> unterstützende adresse zb 16bit wodurch am ende eine 32bit adresse entsteht -> 32bit = 4gb adressraum)

in einem 64bit system musst nicht mit 64bit adressieren, ausser hast über 4gb dann wäre es angebracht.

relativ/absolut brauchst dir keine gedanken drüber zu machen, nimm einfach ausreichend große adresse um deinen adressraum abzudecken, wenn dann die adresse sich auf einen bezugspunkt bezieht (relativ) kannst ehh nichts dagegen machen, weil das der compiler macht / vom OS vorgegeben wird.

LordJaxom

oelsni schrieb:

in einem 64bit system musst nicht mit 64bit adressieren, ausser hast über 4gb dann wäre es angebracht.

Wenn das Betriebssystem und der Compiler im 64-bit Modus laufen hast Du kaum eine andere Wahl als in C++ 64 Bit breite Zeiger zu benutzen

oelsni

kannst auch 32bit verwanden, der compiler wird wohl auf 64bit hochschrauben, aber kannst, mal auf asm ebene gesehen, mit direkten 32bit adressen arbeiten, sowie es auch möglich ist bei 32bit mit 16bit adressen im asm zu arbeiten (was kaum sinn ergäbe, dennoch möglich ist). denn ein prozi der 64bit hat muss dir dennoch die niedrigeren register zu verfügung stellen sonst wäre er nicht abwärtskombatilble. und wenn dann nen 32bit register als adressangabe nutzt dann geht das genauso wie mit 64bit (außer hast über 4gb was den adressraum von 32bit übersteigt).

32bit bei 4gb ram -> 0xffffffff == ende der 4gb
64bit bei 4gb ram -> 0x00000000ffffffff == ende der 4gb (die nullen kannst dir also sparen)

aber wie gesagt das ist die funktionsweise auf unterster ebene und hat nix mehr wirklich mit hochsprachen zu tun. denn der compiler passt deine adressangaben ehh an sodas es bei hochsprachen, mit großer warscheinlichkeit, keine rolle spielt. nur wenn du 16bit verwendest 0xffff wirst deinen adressraum nicht abdecken können, selbst wenn der compiler 64bit daraus macht weil es fehlen an sich informationen, und zwar 16bit (bei <=4gb). denn dem prozi ist recht egal wie groß die adresse ist er geht halt dann dort hin wohin die adresse zeit und wenn sie zu klein ist für dein raum wirst nie das ende erreichen können. aber wie gesagt das ist echt unterste ebene.