Brauche Ratschläge

Guten Abend

Ich möchte etwas loswerden : Die C-Sprache finde ich sehr interessant. Alles ist sehr verständlich. ( bis jetzt! ) . Oft begebe ich mich aber in sehr tiefene Ebenen. Ich habe mich mit dem Thema "Heap / Speicherstruktur / verwaltung" beschäftigt --> Was sind in Wirklichkeit Variablen : Mehrere S.zellen zsammen --> Die Sp.adressen werden vom Comp. je nach Deklaration unterschiedlich interpretiert.

Das hat viele Vorteile : Man versteht einiges.. Doch damit habe ich mir leider ins eigene Bein geschossen. Auf einmal muss ich über die leichtesten Sachen ( variablen, array ) nachdenken, habe einfach Denkblokaden.

int iarray[5] --> Der Comp. merkt sich die Anfangsadresse && springe um 2 x int - vars nach rechts, springen von d. Sp.adresse einer int-var zur Sp.adresse einer and. int-var --> wieso denn? wie funktioniert das?

Ich bin schon richtig gut in C, aber im Moment komme ich nicht weiter. Ich wünschte , ich könnte die Zeit zurückdrehen.

Blue-Tiger

Wenn dich so tiefe Ebenen interessieren, solltest du dich mit Assembler beschaeftigen, dann wirst du sehr genau lernen wie der Computer arbeitet und was hinter den C-Konstrukten steckt.

Ansonsten versteh ich deine Frage nicht

Das Problem ist ja , das ich nun sehr genau weiß , was hinter den C-Konstrukten steckt. Deswegen finde ich viele Sachen nicht mehr logisch :

int iarray[3] --> Früher konnte ich es mir dadurch erklären : Der Compiler merkt sich die Sp.adresse des ersten Feldelementes . Mit dem Indizierungsoperator kann man von dieser Sp.adresse aus zu den anderen Sp.adressen springen ( stimmt nicht : Mehrere Sp.adressen gehören einer Variable .. ) .

Zweite Möglichkeit :
durch die Deklaration : int iarray... weiß der Compiler : iarray zeigt auf eine 4 Byte große int-Variable. Mit dem Indizierungsoperator springt man auf die nächste int-Variable ( man springt um 3 Sp.adressen nach rechts ) ...

Mir fallen solche und noch tiefere Gedanken ein.. Mir fällt es inzwischen schwer die Logik von Arrayübergabe an Funktionen zu verstehen...

Ich habe Angst in C nicht mehr weiterzukommen. Ich finde C sehr wichtig.

LordJaxom

Du solltest erstmal die Sätze etwas besser strukturieren - nicht so viele Abkürzungen und Satzzeichen, dann kann man besser verstehen, was Du möchtest

durch die Deklaration : int iarray... weiß der Compiler : iarray zeigt auf eine 4 Byte große int-Variable.

Hä? Nein, iarray zeigt auf garnichts, weil es kein Zeiger ist. iarray ist ein Symbol (ein Name) für eine Speicherstelle, die ein Integer fassen kann (das sind üblicherweise 4 Byte, aber auch nicht immer). Den Indizierungsoperator kannst Du garnicht anwenden, weil es weder ein Zeiger noch ein Array ist.

Blue-Tiger

Ein Array ist eine Reihe von aufeinanderfolgenden Variablen gleicher Groesse. Ein int-Array der Groesse 10 sind 10 aufeinanderfolgende Integers.
Der Name des Arrays kann als Pointer auf den Anfang des ersten Elements verwendet werden.

int array[10];
int* arrayStart = array;  // jetzt haben wir einen Pointer auf das erste Element

// arrayStart enthaelt die Adresse des 1. Elements. wenn wir sizeof(int) (in der Regel 4 Byte) weitergehen, haben wir die Adresse des 2. Elements:
int* secondElement = arrayStart + sizeof(int); // jetzt haben wir einen Zeiger auf das 2te Element.

int* thirdElement = arrayStart + 2*sizeof(int); // jetzt springen wir vom Start um 2 Elemente weiter und landen beim dritten Element

// ALLGEMEIN GILT:
array[i] == *(array + i*sizeof(int));

HTH

mcr

Blue-Tiger schrieb:

Ein Array ist eine Reihe von aufeinanderfolgenden Variablen gleicher Groesse. Ein int-Array der Groesse 10 sind 10 aufeinanderfolgende Integers.
Der Name des Arrays kann als Pointer auf den Anfang des ersten Elements verwendet werden.
int array[10];
int* arrayStart = array;  // jetzt haben wir einen Pointer auf das erste Element

// arrayStart enthaelt die Adresse des 1. Elements. wenn wir sizeof(int) (in der Regel 4 Byte) weitergehen, haben wir die Adresse des 2. Elements:
int* secondElement = arrayStart + sizeof(int); // jetzt haben wir einen Zeiger auf das 2te Element.

int* thirdElement = arrayStart + 2*sizeof(int); // jetzt springen wir vom Start um 2 Elemente weiter und landen beim dritten Element

// ALLGEMEIN GILT:
array[i] == *(array + i*sizeof(int));
HTH

Fast, du hast einen Fehler gemacht:

int* secondElement = arrayStart + sizeof(int); // <-- hier ist ein Fehler
int* secondElement = arrayStart + 1;           // <-- so ist das richtig

Der Compiler kennt die Größe eines int, so dass er bei arrayStart + 1 direkt
sizeof(int)-Bytes weiterspringt.

Ansonsten stimmt deine Aussage.

Allgemein:

array[i] == *(array + i);

Gruß mcr

Zeit schrieb:

( stimmt nicht : Mehrere Sp.adressen gehören einer Variable .. ) .

es kommt drauf an, wie's deine maschinenarchitektur macht. es gibt computer (z.b. unsere allseits beliebten x86'er), die können/sollen/müssen den speicher byteweise adressieren. bei diesen geräten setzt sich eine int-variable aus 2 oder mehr aufeinanderfolgenden bytes (== octets == 8bit-werte) zusammen. weil der c-standard minimalgrössen für 'int' vorgibt, braucht man mindestens 2-bytes dafür. andere maschinen haben gar nicht die möglichkeit, einzelne bytes zu adressieren, sondern jede speicherzelle hat 16bits. ...mit der konsequenz, dass 'adresse+1' immer 16bits weiterschaltet und 'char' auch 16bits hat (weniger geht eben nicht). hierbei würde ein 'int' vollständig in eine speicherzelle passen und bräuchte nicht zuzsammengesetzt zu werden, wie bei einer byteadressierbaren architektur.