#include <iostream>
using namespace std;

int main(int argc, char *argv[])
{
  cout << argc << " Parameter\n";

  //gleiche adresse wie erstes element in for
  cout << "Speicheradresse des arrays: " << argv << endl; //erstes elemetn
  cout << "Und der Wert?: " << *argv << endl << endl; //programname 
  // !!! warum benoetige ich hier zwei endl um ein endl zu machen???

  int i = 0; 
  //array nur mit pointer durchlaufen
  //solange wir den wert lesen duerfen - also != segmentation fault
  for(char **p = argv; *p; ++p)
  { 
    cout << "p fuer element " << i << ": " << p << endl; //speicher adresse der einzelnen zeilen
    cout << "*p fuer element " << i << ": " << *p << endl; //was steht in der zeile?
    cout << "**p fuer element " << i << ": " << **p << endl; //???
    cout << endl;
    ++i;
  }
  cout << "*** done ***" << endl;

  return 0;
}

hier meine gedanken dazu:

das im parameter uebergebene

char *argv[]

ist ja ein array von pointern auch chars.
(bitte korrigieren wenn ich was falsches sage!)
hier gleich mal eine frage, es ist ja so dass sich nicht nur chars sondern strings verbergen, also ist es immer nur ein pointer auf das erste zeichen des strings. dieses zeichen hat je nachdem wie lang der eingegeben string war, genau so viel speicherplatz reserviert dass sich das ganze wort ausgeht.
wenn ich

argv

also die erste adresse des arrays inkrementiere bekomme ich den ersten speicherplatzt des zweiten strings.

zu meinem programm, ich moechte das ganze array mit einem pointer durchgehen.
also muss ich einen doppel pointer vom typ char machen der mir (zu beginn) auf die erste speicheradresse zeigt.

nun meine große frage was in der for schleife passiert:
mit p, das verstehe ich noch gebe ich die adresse aus an der ich mich befinde.
also nach jeder iteration um genau 4 stellen (ein char) weiter.
mit dem ersten * gehe ich eine ebene hoeher, dass dachte ich mir da ich ja einenen pointer auf einen pointer habe muesste auch eine adresse sein, ist es aber nicht wie ich sehe, es ist der komplette string.
um mich ganz zu verwirren gibt mir dann **p nur den ersten buchstaben aus??

waere nett wenn mir das jemand erklaeren koennte - DANKE!

falls es interessiert, der output:

4 Parameter
Speicheradresse des arrays: 0x6116b6d0
Und der Wert?: pointerTest

p fuer element 0: 0x6116b6d0
*p fuer element 0: pointerTest
**p fuer element 0: p

p fuer element 1: 0x6116b6d4
*p fuer element 1: eins
**p fuer element 1: e

p fuer element 2: 0x6116b6d8
*p fuer element 2: zwei
**p fuer element 2: z

p fuer element 3: 0x6116b6dc
*p fuer element 3: drei
**p fuer element 3: d

*** done ***

das im parameter uebergebene

char *argv[]

ist ja ein array von pointern auch chars.
(bitte korrigieren wenn ich was falsches sage!)

Genau genommen ist es nur ein Zeiger auf einen Zeiger auf einen char . Arrays können an sich nicht übergeben werden, jedoch kann der Zeiger in deinem Fall fast wie ein Array gehandhabt werden, da er auf einen zusammenhängenden Speicherbereich zeigt. Es verhält sich also wie ein dynamisches Array.

AbsoluterBeginner schrieb:

dieses zeichen hat je nachdem wie lang der eingegeben string war, genau so viel speicherplatz reserviert dass sich das ganze wort ausgeht.

Nein. Im ersten Zeichen wird keine Information ausser dem Zeichen selbst gespeichert. C-Strings sind nullterminiert, d.h. das Zeichen '\0' markiert das Ende der Zeichenkette.

AbsoluterBeginner schrieb:

wenn ich

argv

also die erste adresse des arrays inkrementiere bekomme ich den ersten speicherplatzt des zweiten strings.

Ja, der char** -Zeiger verweist dann auf den nächsten char*- Zeiger, also den nächsten C-String.

AbsoluterBeginner schrieb:

zu meinem programm, ich moechte das ganze array mit einem pointer durchgehen.
also muss ich einen doppel pointer vom typ char machen der mir (zu beginn) auf die erste speicheradresse zeigt.

Ja, das ist eine Möglichkeit. Du kannst aber auch den übergebenen Zeiger direkt verwenden oder auf STL-Algorithmen zurückgreifen, aber das ist wahrscheinlich noch etwas zu früh.

AbsoluterBeginner schrieb:

mit dem ersten * gehe ich eine ebene hoeher, dass dachte ich mir da ich ja einenen pointer auf einen pointer habe muesste auch eine adresse sein, ist es aber nicht wie ich sehe, es ist der komplette string.

Du verwechselst da die Operatoren * und &, die entgegengesetzte Bedeutung haben. operator* dereferenziert einen Zeiger, das heisst, er gibt den Speicherbereich zurück, auf den er verweist. operator& gibt die Adresse einer Variable zurück.

AbsoluterBeginner schrieb:

um mich ganz zu verwirren gibt mir dann **p nur den ersten buchstaben aus??

Ja, du dereferenzierst ja p zwei Mal. Beim ersten Mal greifst du auf den Inhalt von p zu, also das (dynamische) Array von char* (entspricht dem ersten String). Beim zweiten Mal dereferenzierst du gerade den ersten dieser C-Strings und greifst auf dessen erstes Element vom Typ char zu.

Aber lies doch noch einmal den Artikel über Zeiger, den ich dir angegeben habe, dort wird wirklich alles gut beschrieben!

mit dem ersten * gehe ich eine ebene hoeher, dass dachte ich mir da ich ja einenen pointer auf einen pointer habe muesste auch eine adresse sein, ist es aber nicht wie ich sehe, es ist der komplette string.
um mich ganz zu verwirren gibt mir dann **p nur den ersten buchstaben aus??

Klingt für mich nach einem kleinen Verständnisproblem. Ein c-string ist nichts anderes als ein char*, denn C kennt keinen string Datentyp. Wenn eine Funktion irgendwas mit einem String machen möchte, lässt sie sich einfach einen pointer auf dessen ersten char geben (also einen char*). Wenn sie nun den restlichen string bearbeiten will, erhöht sie einfach den pointer um 1, so dass er auf den nächsten Buchstaben zeigt. Das macht sie solange bis sie auf '\0' trifft, woran sie erkennt das dort der string zuende ist. Ein char** stellt damit tatsächlich ein Array von strings da (ein Zeiger auf das erste Element des Arrays, was ja nun ein char* also ein string ist).

Wenn du nun mit dem ersten * eine Ebene höher gehst, bekommst du, wie du oben vermutest, tatsächlich eine Adresse (einen char*). Und wie du auch richtig beobachtest, ist das gleichzeitig als string interpretierbar (nach meiner Erklärung oben solltest du verstehen warum). Cout weiß auch das es char* als string zu interpretieren hat, daher bekommst du den ganzen string ausgeben.

Nunja wenn du nun noch das zweite * dazunimmst, wird aus deinem Zeiger auf den ersten char des strings direkt der erste char des strings. Auch das hast du ja beobachtet. Ich hoffe das war jetzt nicht zu verwirrend.

Wenn du nun mit dem ersten * eine Ebene höher gehst, bekommst du, wie du oben vermutest, tatsächlich eine Adresse (einen char*)

Eben nicht. Mit dem *-Operator geht man eine Ebene tiefer, also auf den verwiesenen Speicherbereich (Dereferenzierung). Dadurch erhält man nicht zwingend eine Adresse - in diesem Falle nur, weil der Zeiger selbst wieder auf einen Zeiger zeigt.

Und was das Ebenen-Problem betrifft: Für mich ist halt die unterste Ebene dort, wo direkt mit der Variable gearbeitet wird. Abstaktion (somit auch Indirektion) bedeutet für mich höhere Ebene...

[quote="HyperSonic"]

AbsoluterBeginner schrieb:

...Cout weiß auch das es char* als string zu interpretieren hat, daher bekommst du den ganzen string ausgeben.

das hat mir entgueltig die augen geoffnet, kann man ja nicht wissen dass cout automatisch ein char* als string interpretiert und ausgiebt.

also werde mich mal weiter spielen hehe
gefaellt mir das forum hier - danke nochmal an euch beiden!!
schoenen abend noch...