Zeiger und Zähleropertor *x++

mathgirl

Hallo liebe Freunde

so ganz mit dem Zeiger haber ich es noch nicht verstanden :

(int *indx)

int ind=1

*indxc++ =ind <== heisst das etwa indxc=indxc+ind???
ich weiss net genau was für einen Wert indxc hat ???
vlt. etwa indxc=ind???
Auf welche Adresse weist der der Zeiger *indxc hin?
Und ist der Zeiger hier auch sowas wie ein Zähleroperator?? sowas wie
sum=1
for j=1:N
sum=sum+ind
end

volkard

mathgirl schrieb:

*indxc++ =ind <== heisst das etwa indxc=indxc+ind???

*indxc++ =ind heisst *indxc=ind;indxc+=1;
und
*++indxc =ind heisst indxc+=1;*indxc=ind;

hustbaer

volkard schrieb:

*indxc++ =ind heisst *indxc=ind;indxc+=1;

Ich finde es weniger verwirrend wenn man schreibt:
`temp = indxc;

indxc++;

*temp = ind;

`

Wobei auch das "falsch" ist. Weil nicht definiert ist wann genau das indxc++ ausgeführt wird. Weswegen man auch nicht
*indxc++ = (int)indxc;
schreiben darf.

mathgirl schrieb:

*indxc++ =ind <== heisst das etwa indxc=indxc+ind???

Das heisst: zuerst wird der Inhalt der Variablen ind dorthin kopiert worauf der Pointer indxc zeigt, und danach wird indxc um "1" hochgezählt.

Zur dieser "1": der Wert von indxc erhöhlt sich dabei um sizeof(*indxc).

hustbaer schrieb:

volkard schrieb:

*indxc++ =ind heisst *indxc=ind;indxc+=1;

Ich finde es weniger verwirrend wenn man schreibt:
`temp = indxc;

indxc++;

*temp = ind;

`

Wobei auch das "falsch" ist. Weil nicht definiert ist wann genau das indxc++ ausgeführt wird. Weswegen man auch nicht
*indxc++ = (int)indxc;
schreiben darf.

Das ist sehr wohl definiert und man "darf" es auch so schreiben.

hustbaer

Das wäre ja mal ganz was neues.
Nach dem alten Standard ist es auf jeden Fall nicht erlaubt.

hustbaer schrieb:

Das wäre ja mal ganz was neues.
Nach dem alten Standard ist es auf jeden Fall nicht erlaubt.

Vermutlich gibt es Abermilliarden Quelltexte, die ein

*ptr++ = irgendwas;

völlig problemlos machen. Das Hochzählen des Pointers findet immer erst nach der Zuweisung statt, egal was sich hinter "irgendwas" auch verbergen mag.

Kann vieleicht sein dass es manchmal zickt, wenn ++ ein überladener Operator ist, aber bei primitiven Datentypen ist sowas absolut stressfrei.

volkard

Z schrieb:

hustbaer schrieb:

Das wäre ja mal ganz was neues.
Nach dem alten Standard ist es auf jeden Fall nicht erlaubt.

Vermutlich gibt es Abermilliarden Quelltexte, die ein
*ptr++ = irgendwas;
völlig problemlos machen. Das Hochzählen des Pointers findet immer erst nach der Zuweisung statt, egal was sich hinter "irgendwas" auch verbergen mag.

Kann vieleicht sein dass es manchmal zickt, wenn ++ ein überladener Operator ist, aber bei primitiven Datentypen ist sowas absolut stressfrei.

Ja, aber WANN in dem Ausdruck das Inkrementieren ausgeführt wird, ist nicht spezifiziert.

*ptr++ = irgendwasAnderes;

ist VOLL ok!
Dagegen

*ptr++ = ptr;

aber nicht.

i=a++ + ++b;

ist voll ok.
Aber

a=a++ + ++a;

eben wieder nicht.
Weil unklar ist und explizit dem Compiler überlassen wird, wann er sich benüßigt fühlen mag, die Inkrementierungen auszuführen.

Ob es erlaubt ist, das zu schreiben? Wenn ich mich recht erinnere, darf man es schreiben. Zum Beispiel, um einen Zufallszahlengernertaor zu bauen.

Stimmt, das kenne ich. Wenn die inkrementierte Variable mehrfach im Ausdruck auftaucht, in dem sie hochgezählt wird, passiert selten das, was man eigentlich wollte.

volkard

Z schrieb:

Stimmt, das kenne ich. Wenn die inkrementierte Variable mehrfach im Ausdruck auftaucht, in dem sie hochgezählt wird, passiert selten das, was man eigentlich wollte.

Und nicht nur dann. Wenn man im GCC den Götterhammer "-O3" anschaltet, lernt man den Standard kennen. Oh, es ist für signed-Typen nicht spezifiziert, was sie beim Überlauf machen? Klar, der Götterhammer entscheidet sich dafür, daß er stets den ge-if-ten Code wegoptimiert. Er darf ja. Brutal.

Außerdem halte ich es für fast immer besser lesbar, ++ in eine eigene Anweisung zu setzen.
Ich kann

++i;
x=tab[i];

einfach besser lesen als

x=tab[++i];

Einzige Ausnahmen:

*writePos++=read();

und das duale

write(*readPos++);

Nur wenn es um schlichtes lineares Auslesen von char-Arrays geht, mache ich das. Sobald ein Algo ein wenig komplexer wird, landet das ++ in einer eigenen Zeile.

volkard schrieb:

Nur wenn es um schlichtes lineares Auslesen von char-Arrays geht, mache ich das. Sobald ein Algo ein wenig komplexer wird, landet das ++ in einer eigenen Zeile.

Ich bin noch extremer. Anstatt:

for (...; ...; n++)

, mache ich hin und wieder:

for(;;)
{
   ...
   n++;
   ...
   if (n == fertig) break;
   ...
}

Das hat den Vorteil, dass der Sprung aus der Schleife unabhängig von der Stelle ist, an der die Zählvariable verändert wird, so dass ein Teil des Schleifencodes ausgeführt werden kann, obwohl die Abbruchbedingung schon erreicht ist. Zudem macht das den Code linear lesbar. Denn das n++ im Kopf der For-Schleife muss man sich sonst ja als letzte Aktion in die Schleife denken.

Aber manche mögen sowas nicht, denn es grenzt schon an Goto-Programmierung. :p

C++ Forumbot

Dieser Thread wurde von Moderator/in Martin Richter aus dem Forum MFC (Visual C++) in das Forum C++ (auch C++0x und C++11) verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

SeppJ

Zwar widerspricht nichts im Thread der Annahme, es ginge um C++, aber aus den anderen Threads von mathgirl weiß ich, dass es um C geht.

C++ Forumbot

Dieser Thread wurde von Moderator/in SeppJ aus dem Forum C++ (auch C++0x und C++11) in das Forum C (C89, C99 und C11) verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

krümelkacker

Das einzige wahrscheinlich Relevante, was ich der "Frage" entnehmen kann ist, folgender Ausdruck

*indxc++ = ind;

Habe ich das richtig verstanden, dass mathgirl wissen will, wie dieser Ausdruck zu verstehen ist, wenn indxc ein int-Zeiger und ind eine int-Variable ist?

Das, was da passiert, ist gleichbedeutend mit

*indxc = ind;
indxc++;

Das Postfix-++ bindet zwar stärker -- die linke Seite des Gleichheitszeichens lässt sich also *(indxc++) schreiben -- aber Postfix-++ verspricht, den alten Wert zurückzugeben. indxc wird hier also inkrementiert, und an den Speicherort der alten Adresse wird etwas reingeschrieben (oder umgekehrt, die Reihenfolge ist nicht spezifiziert, hier aber auch nicht wichtig).