Moin,

denn was bedeutet nun ++argv in der 1. und ++*argv in der 2. Schleife? ++argv zu inkrementieren bedeutet von der Logik her also "zeige auf den nächsten Zeiger in meinem Array?"

ja, das ist richtig.

Für mich wäre es logisch gewesen, würde dort ++*argv inder 1. und ++**argv in der 2. Schleife stehen

++*argv würde bedeuten: Nimm das Element, auf das argv zeigt, und erhöhe es. Da *argv seinerseits auf char zeigt, würde dieser Zeiger um 1 erhöht, so dass er auf das nächste Zeichen im String (Kommandozeilenargument) zeigt.
++**argv hieße jedoch: Nimm das Element, auf das argv zeigt (das ist selbst wieder ein Zeiger), und erhöhe das Element, auf das dieser Zeiger verweist. Da (**argv) ein char ist, würde also der Wert des ersten Zeichens im String erhöht.

Ich dachte nämlich, dass ich auf die einzelnen Elemente (die die Kommandozeilenargumente enthalten) in dem Array von Zeigern mit *argv zugreife.

Das ist auch so.

Bei der Ausgabe von printf ist es für mich wieder logisch, wnen ich **argv ausgebe

Für mich nicht - aber du gibst den String auch Zeichen für Zeichen aus (als printf-Format %c), darum ist **argv richtig. Intuitiver finde ich es, mit dem Format %s den gesamten String *argv am Stück auszugeben.

Eines verstehe ich dabei noch weniger. Ich könnte genauso gut folgendes schreiben:

for(; *argv; argv++)

{
        for(; **argv; (*argv)++)
                printf("%c\n", **argv);
}

  
Anmerkung zum Stil: Eine for-Schleife ohne Initialisierung ist zwar syntaktisch erlaubt und korrekt, wirkt immer etwas ... hmm, "defekt". Ich würde in einem solchen Fall zur while-Schleife greifen.  
  

> (\*argv)++ erhöht doch den WERT, worauf der Zeiger zeigt  
  
Genau, und der Zeiger zeigt auf einen Zeiger - der WERT ist in diesem Fall also nicht char, sondern char\*, ein Zeiger auf char. Also wird ein Zeiger auf char um ein Zeichen weitergezählt.  
  

> d.h. würde an dieser Stelle ein "u" stehen, müsste dieses "u" auf ein "v" inkrementiert werden, da "v" das nächste Zeichen nach "u" ist.  
  
Nein, das passiert erst, wenn du zweimal dereferenzierst (also \*\*argv oder \*argv[0]).  
  
 Ausdruck    Typ  
 argv       char\*\*     Zeiger auf Zeiger auf ein Zeichen  
 \*argv      char\*      Zeiger auf ein Zeichen  
 \*\*argv     char       Zeichen  
 argv[x]    char\*  
 \*argv[x]   char  
  
Jetzt klarer?  
  
So long,  
 Martin  

-- 
Zwischen Leber und Milz  
passt immer noch'n Pils.

»»Bei der Ausgabe von printf ist es für mich wieder logisch, wnen ich **argv ausgebe, aber warum inkrementiere ich dann nicht auch in der 2. Schleife so: (**argv)++, bzw ++**argv?

weil du dann die einzelnen buchstaben inkrementieren würdest.
argv++ geht immer von einem argument zum nächsten (++ auf pointer auf pointer (array) auf Buchstaben)
(*argv)++ geht von buchstabe zu buchstabe (++ auf pointer (array) auf Buchstaben)
(*(*argv))++ inkrementiert den 1. buchstaben (++ auf Buchstaben)

Eines verstehe ich dabei noch weniger. Ich könnte genauso gut folgendes schreiben

pre- und postfix operatoren:
a++; merkt sich erst den wert, inkrementiert diesen und kiefert den gemerkten
++a; inkrementiert erst und liefert dann den inkrementiertn wert

int a = 7;
int b = a++; // b ist 7 und a ist 8
int c = ++b; // c ist 8 und b ist 8

hier in der schleife ist das eigentlich egal. beim (*argv)++ wird zwar ein nicht benötigtes temporary angelegt, ein guter compiler sollte das aber bei einfachen datentypen wegoptimieren.

(*argv)++ erhöht doch den WERT, worauf der Zeiger zeigt, d.h. würde an dieser Stelle ein "u" stehen, müsste dieses "u" auf ein "v" inkrementiert werden, da "v" das nächste Zeichen nach "u" ist. Tut es aber nicht. Es funktioniert so richtig. Logisch wäre für mich aber wieder gewesen, wenn ich *(argv++) schriebe, denn das inkrementiert den Zeiger doch auf die nächste Position.

(*argv)++ inkrementiert den dereferenzierten pointer auf pointer auf buchstaben. also den pointer auf buchstaben.
*(argv++) inkrementiert den pointer auf pointer auf buchstaben und dereferenzierten ihn dann. also bei ["123", "345", "678"] und argv zeigt auf den anfang, würde erst argv auf "345" gesetzt und dieses zurückgegeben. im ersten fall wurde der inhalt von argv inkrementiert (also "123" wurde zu "23")