Wenn ich schreibe:

void blup(char *a, char  *b)
{
    while ( *a = *b );
}

*a zeigt ja dann auf *b

Somit endet es in einer Endlosschleife.

Und wenn ich schreibe:

void blup(char *a, char  *b)
{
while ( *a++ = *b++ );
}

a zeigt auf den Nullpointer seiner eigenen Variable b ebenso.

Und wenn ich folgendes, schreibe:
Dann sollte doch eigentlich innerhalb der while Schleife undefiniertes Verhalten auftreten ist das richtig?

void blup(char *a, char  *b)
{
*a++;
*b++;

while ( *a++ = *b++ );
}

char *a="A"; // Reserviert 1 Byte für das A und 1 Byte für den Nullterminator
*a++; // *a zeigt auf den Nullterminator
*a++; // *a zeigt auf vielleicht auf den Weg zum Millionär :D (undefiniertes Verhalten^^)

Kann man das so beschrieben?

void blup(char *a, char  *b)
{
    while ( *a = *b );
}

*a zeigt ja dann auf *b

Somit endet es in einer Endlosschleife.

Eventuell. Erstmal ist a der Zeiger, und nicht *a. Zweitens könnte in *b der Wert 0 stehen, sodass die Schleife abbricht.

Der Zeiger untersucher! schrieb:

Und wenn ich folgendes, schreibe:
Dann sollte doch eigentlich innerhalb der while Schleife undefiniertes Verhalten auftreten ist das richtig?

void blup(char *a, char  *b)
{
*a++;
*b++;

while ( *a++ = *b++ );
}

Ja da hast du früher oder später UB, du irgendwann *a einen Wert zuweist, obwohl dir der Speicherbereich gar nicht gehört. Es sei denn, in *b steht gleich wieder eine 0 drin.

Der Zeiger untersucher! schrieb:

char *a="A"; // Reserviert 1 Byte für das A und 1 Byte für den Nullterminator
*a++; // *a zeigt auf den Nullterminator
*a++; // *a zeigt auf vielleicht auf den Weg zum Millionär :D (undefiniertes Verhalten^^)

Kann man das so beschrieben?

Fast.
1. *a++; --> a zeigt auf '\0' und wird dann dereferenziert.
2. *a++; --> a zeigt auf irgendwas und wird dann dereferenziert.
Beides ist ok. Es wäre nur dann UB, wenn du *a noch etwas zuweisen würdest. Bei 1. weil *a const ist. Bei 2. weil dir der Speicherplatz bei *a nicht gehört.

while ( *a = *b );

Du weist hier jeweils dem Objekt auf das a Zeigt den Wert zu, auf den b zeigt. Solange, bis einer dieser Werte 0 ist. Da sich der Wert nicht ändern wird, ist das entweder nur ein Durchlauf (es ist 0) oder eine Endlosschleife (falls nicht).

while ( *a++ = *b++ );

Wie oben, aber du setzt a und b jeweils 1 weiter, verweist also auf das Objekt "eins weiter". Kommt wieder drauf an, auf was a und b überhaupt zeigen.

*a++;

Erhöht den Pointer a, holt den Wert auf den a zeigt, macht mit diesem gar nichts.

char *a="A"; // Reserviert 1 Byte für das A und 1 Byte für den Nullterminator

Reserviert gar nix, außer den Zeiger a. Dieser zeigt auf ein Zeichenkettenliteral im Datensegment des Programms.

*a++; // *a zeigt auf den Nullterminator

Ja. Außerdem schaust du dir das Nullzeichen mit dem * an. Siehe oben. Macht wieder gar nix.

*a++; // *a zeigt auf vielleicht auf den Weg zum Millionär (undefiniertes Verhalten^^)

Ja, das ist nun undefiniert, weil du dir wer weiß was anguckt. edit: Nein, verzählt. Er zeigt ja noch auf die Null. Erst eines weiter wäre undefiniert.

So ganz scheinst du die Bedeutung von dem Sternchen nicht verstanden zu haben. Bei einer Variablendefinition ziegt es einen Pointertyp an, wenn du es auf einen Pointer anwendest, dann heißt es, dass du dich auf den Wert beziehst, auf den gezeigt wird.

*a zeigt ja dann auf *b

Somit endet es in einer Endlosschleife.

Nicht ganz, der Stelle, an die a zeigt wird der Wert der Stelle an die b zeigt zugewiesen und es wird bei der Zuweisung normalerweise eine Referenz auf this zurückgegeben bzw. im Falle von char wird hier einfach *a zurückgegeben. Es endet also in einer Endlosschleife, wenn weder a noch b auf 0 zeigen.
Wenn du willst, dass *a auf b zeigt musst du a = b schreiben. Dann zeigt a auf dieselbe Stelle im Speicher wie b.

a zeigt auf den Nullpointer seiner eigenen Variable b ebenso.

Ne, a und b werden jeweils solange inkrementiert, bis die Zuweisung 0 zurückgibt und währenddessen werden alle Werte von *a zu *b kopiert.

Du hast eine falsche Einbildung von dem Dereferenzierungsoperator. Mit diesem (dem greifst du auf den Wert zu, der in an der Stelle im Speicher steht, auf die der Zeiger selbst zeigt. *a = 'a'; weist also der Stelle im Speicher, auf die der Zeiger a zeigt den wert 'a' zu.

Der Zeiger untersucher! schrieb:

void blup(char *a, char  *b)
{
    while ( *a = *b );
}

*a zeigt ja dann auf *b

Somit endet es in einer Endlosschleife.

Eventuell. Erstmal ist a der Zeiger, und nicht *a. Zweitens könnte in *b der Wert 0 stehen, sodass die Schleife abbricht.

Ich hoffe ich störe nicht mit einer Zwischenfrage :).
"=" ist ja eine Zuweisung. Die ist ja immer true oder nicht ? Oder warum bricht da was ab ?
Oder fliegt dann eine Exception ? Wegen Null-Pointer ?

"=" ist ja eine Zuweisung. Die ist ja immer true oder nicht ? Oder warum bricht da was ab ?

Der Wert einer Zuweisung ist der Wert der zugewiesen wird. a = 0 ist z.B. 0 und daher false. (Deswegen funktioniert ja auch a = b = c = 5 und a, b und c sind 5.)

*a++; // *a zeigt auf den Nullterminator

Ja. Außerdem schaust du dir das Nullzeichen mit dem * an. Siehe oben. Macht wieder gar nix.

*a++; // *a zeigt auf vielleicht auf den Weg zum Millionär (undefiniertes Verhalten^^)

Ja, das ist nun undefiniert, weil du dir wer weiß was anguckt.

Sicher? Ich dachte lesen sei erlaubt nur schreiben nicht?

martin_zi schrieb:

"=" ist ja eine Zuweisung. Die ist ja immer true oder nicht ? Oder warum bricht da was ab ?

Der Wert einer Zuweisung ist der Wert der zugewiesen wird. a = 0 ist z.B. 0 und daher false. (Deswegen funktioniert ja auch a = b = c = 5 und a, b und c sind 5.)

Achne .. tatsächlich .. ich bin doch etwas geschockt das mir das noch nicht so bewusst war

Sicher? Ich dachte lesen sei erlaubt nur schreiben nicht?

In dem Beispiel ist das nicht undefiniert, aber das hier

const char* p = "A";
++p;
*++p;

schon.

SeppJ schrieb:

*a++; // *a zeigt auf den Nullterminator

Ja. Außerdem schaust du dir das Nullzeichen mit dem * an. Siehe oben. Macht wieder gar nix.

*a++; // *a zeigt auf vielleicht auf den Weg zum Millionär (undefiniertes Verhalten^^)

Ja, das ist nun undefiniert, weil du dir wer weiß was anguckt.

Sicher? Ich dachte lesen sei erlaubt nur schreiben nicht?

Nein, einen wilden (oder Null-) Zeiger auch nur zu dereferenzieren ist UB.

Sicher? Ich dachte lesen sei erlaubt nur schreiben nicht?

Ja sicher. Die Adresse könnte zum Beispiel gar nicht gemappt sein.

cooky451 schrieb:

In dem Beispiel ist das nicht undefiniert

Klar ist das "undefiniert": http://ideone.com/2E6cm

MfG,

Probe-Nutzer

cooky451 schrieb:

In dem Beispiel ist das nicht undefiniert

Klar ist das "undefiniert": http://ideone.com/2E6cm

C Noob. http://ideone.com/oWQKp

Hallo,

cooky451 schrieb:

In dem Beispiel ist das nicht undefiniert

Klar ist das "undefiniert": http://ideone.com/2E6cm

Nein, es ist nicht undefiniert.

int main()
{
    char *a="A";

soweit ists ja klar, denke ich.

*a++;

hier wird nun a dereferenziert ('A' als ergebnis) und der Zeiger wird um 1 erhöht.

*a++;

hier wird nun der erhöhte Zeiger dereferenziert ('\0' als ergebnis) und der Zeiger wird um 1 erhöht und zeigt somit auf Speicherbereich der wahrscheinlich nicht mehr uns gehört. Aber solange er nur zeigt ist das OK.

Ein weiteres

*a++;

wäre undefiniert.