Zeiger in C auf einem 32-Bit System

Weil ein Int 4 Byte lang ist?

Ist mir auch klar 4 Byte enthalten doch 32 Bit, also müsste doch eine 
Adresse auf einem 32-Bit System ausreichen. Oder leben wir immer noch in 
einer 8-Bit Welt und reden alle von 32 und 64?

> Warum reserviert C bei einem Integer-Zeiger  4 Adressen und nicht eine
> einzige Adresse ( 32-Bit breiter Datenbus )?

Verstehe nicht, was du meinst. Wo werden 4 Adressen reserviert? Ein 
Zeiger kann nur die Adresse eines einzelnen Objekts enthalten. Er hat 
auch nur eine Adresse.

> Gibt es einen 8-Bit bzw. 32-Bit Modus?

Nein. Was soll der denn machen?

> Warscheinlich werden sich jetzt einige an den Kopf fassen und sagen man
> ist der doof :-)

Nein. Man wird ja nicht allwissend geboren. Ich kratz mich nur am Kopf 
und versuche, die Frage zu verstehen. ;-)

Kleines Beispiel was ich meine:

#include<stdio.h>

main()
         {
    int i;
    int mem[5];

    for (i=0; i < 5; i++)
      printf("adr: %x\n", &mem[i]);

          }

Ausgabe:

adr: bfcf40c0
adr: bfcf40c4
adr: bfcf40c8
adr: bfcf40cc
adr: bfcf40d0

Wie man erkennt beträgt das Inkrement 4. Da ich aber eigentlich einen 
32-Bit Datenbus habe sollte doch ein Inkrement von 1 ausrechend für 
einen Integer sein.
Oder sehe ich da etwas falsch?

Ja, das siehste grottenfalsch. Die kleinste_ _adressierbare_ _Einheit 
bei diesem System ist - wie bei vielen anderen auch - das Byte (8 Bit). 
Ein Integer ist bei diesem Compiler 32 Bit lang, benötigt also 4 Bytes. 
Dementsprechend ist die Adress-Differenz zwischen zwei 
aufeinanderfolgenden Elementen dieses Arrays genau 4. Probiere das Ganze 
mit short aus; Du wirst ein Inkrement von 2 erhalten; bei char sinkt das 
Inkrement auf 1.

Bernhard

Ok wenn dem so ist, dann kann aber die Adresse die ich in diesem 
Beispiel erhalte keine real existierende Adresse sein.?

Egal, ob du auf einem 32- oder 16- Bit Rechner arbeitest, kannsst du 
jedes Byte separat ansteuern. Dass die CPU und der RAM gleich 2 bzw 4 
davon verarbeiten könnem ist dafür ohne Belang.

> Die kleinste_ _adressierbare_ _Einheit bei diesem System ist - wie
> bei vielen anderen auch - das Byte

Kunststück. So ist das Byte in der Regel definiert.

> (8 Bit).

Das meistens auch, ja.

@Armin:

Überlege mal: Wenn bei int das Inkrement 1 ist, wie groß müßte es dann 
für Typen sein, die kleiner als int sind?

> Du kannst auf den meisten 32Bit-CPUs auch einen 32bit-Wert an die Byte-Adresse 3 
schreiben

Da hätt ich jetzt gesagt, dass man das bei den meisten Architekturen 
genau nicht kann...

Danke erstmal euch allen.
Mein eigentliches Problem ist, dass ich auf einen RAM Baustein (16-Bit) 
am ISA-Bus zugreifen möchte. Mit dem folgenden kleinen Programm versuch 
ich den RAM auszulesen. Leider erhalte ich nicht alle im RAM enthaltenen 
Werte.

#define BASIS 0xc8000
main()
  {
    int i;
    short mem[32];

    int fd = open("/dev/mem", O_RDWR);

    short *virtbase = mmap(0, 1024, PROT_READ | PROT_WRITE,
      MAP_SHARED, fd, BASIS);

    for (i=0; i < 8; i++){
      mem[i] = virtbase[i];
      //printf("virtbase: %x\n", virtbase[i]);
      }

    for (i=0; i < 8; i++)
      printf("mem: %x\n", mem[i]);
  }

Ergebnis:
mem: 1201
mem: 1403
mem: 1605
mem: 1807

Im RAM entahlten:
 0x1101;
 0x1202;
 0x1303;
 0x1404;
 0x1505;
 0x1606;
 0x1707;
 0x1808;

Wenn ich virtbase und mem als char definiere und das printf nicht 
auskommentiere erhalte ich folgendes Ergebnis:
virtbase: 1
virtbase: 12
virtbase: 3
virtbase: 14
virtbase: 5
virtbase: 16
virtbase: 7
virtbase: 8
mem: 1
mem: 2
mem: 3
mem: 4
mem: 5
mem: 6
mem: 7
mem: 8

Hat jemand eine Idee wie ich richtig an die Daten komme?
Danke!

Das /MEMCS16 Signal wir erzeugt, allerdings etwas später als eigentlich 
nötig. Da ich aber gelesen habe, dass wenn das /MEMCS16 etwas später 
also wärend des 8-Bitlesevorgangs erzeugt wird, wird ein weiterer 
Lesevorgang im selben Zyklus durchgeführt. Dies hab ich auch mit Hilfe 
eines Qszis nachgeprüft. Kann aber natürlich nicht außschließen, dass 
dies Probleme bereitet. Wie kann ich eventuell beweisen, dass es sich um 
ein Probleme bei der Karte handelt?

Ich weiß was in dem RAM enthalten ist, da es ein V-RAM ist, in den ich 
mit einem PIC ( leider kein Atmel (hat Vor- und Nachteile)) Werte 
hineinschreibe.

Ich bin mir inzwischen bei garnichts mehr sicher :-).

#define BASIS 0xC8000
short *virtbase = mmap(0, 1024, PROT_READ | PROT_WRITE,
      MAP_SHARED, fd, BASIS);

void  *  mmap(void *start, size_t length, int prot , int flags, int fd,
       off_t offset);

Die Basisadresse des RAMS ist bei 0xC8000. Die Endadresse ist 0xC83FF.
Wenn ich den Befehl richtig verstanden hab, dann wird der Seicherbereich 
ab offset nach start abgebildet. Lieg ich da ganz falsch???

Problem teilweise gelöst. Hab festgestellt, dass es im 8-Bit Modus 
funktioniert. Ist wohl doch ein Problem mit dem Timing auf dem ISA-Bus.
Danke rufus!
Danke euch allen!

> und der Aufwand, den sonst der Compiler treiben muss macht das System
> ja auch nicht schneller.

Der muß gar keinen Aufwand treiben.

Verbieg dir doch auf nem System welches nur auf ausgerichtete Adressen 
zugreifen kann z.B. einen int* auf eine ungerade Adresse und lies davon 
- der Compiler wird dir das kompilieren, aber funktionieren wirds nicht.

=> Null Aufwand auf der Compilerseite.