Zeiger Verstanden

Tobi3000

int Array[10];

Bedeutet du hast einen Zeiger auf Array[0] und die restlichen Felder werden auf die Adresse des ersten Feldes raufgerechnet.

D.H.
Array[4] == Array[0] + 4sizeof(int)
oder bei char str[10] ist
str[6] = str[0] + 6sizeof[char].

Du hast wenn du ein Array deklarierst einen Zeiger auf das erste Element und dort werden dann die Größen des Typs raufgerechnet.

groovemaster

Tobi3000 schrieb:

int Array[10];

Bedeutet du hast einen Zeiger auf Array[0]

Nö, bedeutet es nicht. Mensch Leute, lernt es doch endlich mal. Arrays und Zeiger sind zwei verschiedene Paar Schuhe, genauso wie Referenzen und Zeiger. Gerade durch solch verbreitetes Halbwissen haben Anfänger Probleme, bei dem Thema auf einen grünen Zweig zu kommen.

Tobi3000

Der Unterschied zwischen Arrays und Pointern liegt nur darin,dass Pointer keinen Speicher reservieren.

Arrays reservieren Speicher und die Elemente sind alle Zeiger auf diesen Speicher.

Wieso sonst funktionieren

int Array[1];
Array[0] = 40;
cout << *Array << '\n';

oder sogar

int Array[1];
Array[0] = 40;
int* pArray = Array;
cout << *pArray << '\n';

Wenn du mal

cout << Array << '\n';

machst,dann hast du sogar den beweis.

GPC

Tobi3000 schrieb:

Arrays reservieren Speicher und die Elemente sind alle Zeiger auf diesen Speicher.

Nein, der Compiler geht hin und nimmt sich die Addresse des ersten Elements und rechnet i * sizeof(Element) drauf, um an's i-te Element zu kommen.

Wieso sonst funktionieren
int Array[1];
Array[0] = 40;
cout << *Array << '\n';

Weil der Name eines Arrays wie ein Zeiger auf das erste Element des Arrays behandelt werden kann.

Tobi3000

Nein, der Compiler geht hin und nimmt sich die Addresse des ersten Elements und rechnet i * sizeof(Element) drauf, um an's i-te Element zu kommen.

Ja das mein ich ja.

Also so,wie ich es im ersten Post geschildert habe.

groovemaster

Noch mehr Halbwissen...

Tobi3000 schrieb:

Der Unterschied zwischen Arrays und Pointern liegt nur darin,dass Pointer keinen Speicher reservieren.

Nein, der Unterschied besteht darin, dass das eine nicht das andere ist. So einfach ist das.

Tobi3000 schrieb:

Arrays reservieren Speicher und die Elemente sind alle Zeiger auf diesen Speicher.

Nö.

Tobi3000 schrieb:

Wieso sonst funktionieren

Weil ein Compiler bei Bedarf implizit umwandeln kann.

Tobi3000 schrieb:

Wenn du mal
cout << Array << '\n';
machst,dann hast du sogar den beweis.

Beweis wofür? Dass cout Adresswerte ausgeben kann?

Wenn du Beweise willst, dann mach mal folgendes:

1. Lies den Standard!

2. Lass dir folgendes ausgeben:

char a[10];
cout << sizeof(a) << '\n';
cout << sizeof(a[0]) << '\n';
cout << sizeof(&a[0]) << '\n';

Nach deiner Theorie wären es alles dieselben Werte, nämlich die Grösse eines Zeigers. Du wirst bemerken, dass dies nicht der Realität entspricht.

Tobi3000

Vielleicht ist es wieder so ein "der Compiler wandelt explizit um" Fall.

Aber stimmt schon ich werd mir mal den Standard durchlesen.

Tobi3000 schrieb:

Vielleicht ist es wieder so ein "der Compiler wandelt explizit um" Fall.

nein implizit! Das ist ein wichtiger unterschied. implizit ist wenn du es ihm nicht gesagt hast, also sozusagen "automatisch" und explizit wenn du es ihm extra ankündigst, also "manuell". Beispiel:

double x = static_cast<float>(30)/9;

neun wird implizit nach float gekastet, 30 wird explizit gecastet. Das ergebnis wird wieder implizit nach double gecastet. (oder vielleicht gibt's auch ne wahrnung)

thordk

wenns nen standard konformer compiler ist, gibs keine warnung.

Thomas ** 0

Array[4] == Array[0] + 4*sizeof(int) 
oder bei char str[10] ist 
str[6] = str[0] + 6*sizeof[char].

Das stimmt nicht. Wenn du einen Zeiger p vom Typ T und einen Integer n addierst wird der Zeiger um n T-Elemente weiter 'geschoben'.
Also ist Array[0] + 4*sizeof(int) nicht das vierte Element, sondern [auf einer 32bit Architektur] das 16te Element.

Bashar

thordk schrieb:

wenns nen standard konformer compiler ist, gibs keine warnung.

Das ist ein sinnfreier Kommentar. Der Standard macht überhaupt keine Aussage dazu, vor was gewarnt werden kann oder muss.

Tobi3000

Thomas (: schrieb:

Array[4] == Array[0] + 4*sizeof(int) 
oder bei char str[10] ist 
str[6] = str[0] + 6*sizeof[char].
Das stimmt nicht. Wenn du einen Zeiger p vom Typ T und einen Integer n addierst wird der Zeiger um n T-Elemente weiter 'geschoben'.
Also ist Array[0] + 4*sizeof(int) nicht das vierte Element, sondern [auf einer 32bit Architektur] das 16te Element.

Ich redete da von der Speicherverwaltung.

Wenn int Array[5] jetzt Array[0] die Adresse 0x1000FF20 hat,dann hat Array[4] die Adresse 0x1000FF30 also Adresse von Array[0] + 4*sizeof(int) .

thordk

Bashar schrieb:

thordk schrieb:

wenns nen standard konformer compiler ist, gibs keine warnung.

Das ist ein sinnfreier Kommentar. Der Standard macht überhaupt keine Aussage dazu, vor was gewarnt werden kann oder muss.

der standard gibt vor, dass bei implizierter typumwandlung von niedrigeren in höhere typen kein informationsverlust stattfinden kann. wozu dann ne warnung? wär unsinn. ungefähr so, als würd man vor ner schleife warnen, die 5 mio. mal durchlaufen wird, weils ja bestimmt nicht so gedacht war.

Bashar

thordk schrieb:

wozu dann ne warnung? wär unsinn.

Richtig, aber das ist wie gesagt keine Frage der Standardkonformität.