char namen[10]; //Sind 10 Zeiger auf ein char ?? ->Sind die char objekte dann schon vorhanden ?;

Was ich nicht so genau verstehe ist folgendes.

int zahlen[10]; //10 Zeiger auf je ein array.
int *cpzahlen;

cpzahlen = &zahlen[2]; //Ich übergebe den zweiten zeiger vom array zahlen nach cpzahlen.

cout << cpzahlen[1]; //Jetzt gabe ich die nächste nach dem array prinzip berechneten pointer von cpzahlen aus. Also dann der 3. pointer vom array zahlen.

Stimmt dass so. Oder hat mir jemand noch ne ganz genau erklärung für dummies ??

Gruss

Dummie

char namen[10]; //Sind 10 Zeiger auf ein char ?? ->Sind die char objekte dann schon vorhanden ?;

Das ist ein Array mit 10 chars, kein Array von Zeigern auf char.

int zahlen[10]; //10 Zeiger auf je ein array.
int *cpzahlen;

Nö, 10 ints. Keine Zeiger.

cpzahlen = &zahlen[2]; //Ich übergebe den zweiten zeiger vom array zahlen nach cpzahlen.

Nö, du weist cpzahlen einen Zeiger auf das 2. Element von zahlen zu.

cout << cpzahlen[1]; //Jetzt gabe ich die nächste nach dem array prinzip berechneten pointer von cpzahlen aus. Also dann der 3. pointer vom array zahlen.

Nein du gibst die Zahl aus, die an 3. Stelle im Array steht.

Wenn nicht wie funktioniert ein Array denn.

Hi, ich dachte ein Array speichert einfach die adressen auf zb. 10 char , int usw.

Nein. Ein Array speichert immer die Objekte, die mit dem Typ angegeben wurde. Wenn du Zeiger speichern willst, zB Zeiger auf char, dann musst du dies auch so schreiben.

char* blubb[10];

Und wenn du wissen willst, wie Arrays funktionieren, dann würde ich dir ein entsprechendes Tutorial empfehlen, zB hier.

char *namen[10][20];

Ich dachte dass sind 10 Zeiger auf 10arrays mit 20chars.

Aber wenn das so wäre müsste ja folgendes funktionieren:

namen[0] = "1234567891234567890";

Und was bedeutet denn dass ??

char *namen[10][20];

Ich dachte dass sind 10 Zeiger auf 10arrays mit 20chars.

Nein, das sind 10 Arrays, die je 20 Zeiger auf char enthalten.
Was du meinst schreibt sich

char (*namen[10])[20];

Allerdings solltest du nicht versuchen, das zu verstehen, wenn du mit einfachen Arrays noch Schwierigkeiten hast

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.

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.

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.

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.

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.

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.

Aber stimmt schon ich werd mir mal den Standard durchlesen.

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)

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.

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.

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 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.

wozu dann ne warnung? wär unsinn.

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