Nebenfrage: Wofuer sind Zeiger denn jetzt sinnvoll? In meinem Buch wird erwaehnt, dass Zeiger unverzichtbar fuer C++ waeren... aber es wird nicht erwaehnt wofuer!? Ist eine Referenz nicht das gleiche?

char& Referenz = einZeichen;

char *ZeigerAufZeichen = &einZeichen;

Hier sehe ich keinen Unterschied...

Sorry fuer die peinliche Anfaengerfrage, aber ich komm einfach nicht drauf.

Gruss
Cartman, der bis jetzt noch nie mit Zeigern zu tun hatte

const char* Ptr;  // meiner Ansicht nach schöner ;)
char const* Ptr;  // wirklich konsequent

Der Zeiger selber ist nicht konstant, der referenzierte char aber schon.

char* const Ptr;

Der Zeiger ist konstant, der char aber nicht.

char const* const Ptr;

Konstanter Zeiger auf konstanten char .

Referenzen verhalten sich im Grunde genommen wie eingeschränkte Zeiger. Man muss sie bei der Definition mit einem gültigen Objekt (nicht Null) initialisieren und sie können nicht verändert werden, verweisen also während ihrer Lebensdauer auf das selbe Objekt. Zudem ist die Syntax ein wenig einfacher, da Referenzen beim Zugriff automatisch dereferenziert werden. An vielen Orten sind Referenzen praktisch und teilweise sicherer, aber für gewisse Dinge (Speicherverwaltung z.B., oder Verweise auf Objekte, die ungültig sein können oder sich verändern) muss man Zeiger nehmen.

Ich sage jetzt mit Absicht nichts dazu.

-> Link zu Artikel über Zeiger

Okay, zugegeben, hab vergessen zu suchen, bevor ich ein neuen Thread eroeffne. Ich entschuldige mich, eigentlich achte ich darauf
Zum Thema const char* und char* const:
Sehe ich das jetzt richtig, dass const char* ein Zeiger auf ein konstantes char ist und der Wert der Variable (auf die der Zeiger zeigt) nicht durch den Zeiger veraendert werden kann, aber sehr wohl die Adresse (sodass der Zeiger dann auf ein anderes Zeichen zeigt)?

const char* ZeigerAufZeichen = &einZeichen;

	ZeigerAufZeichen = &zeich2;

Wenn das Sternchen weggelassen wird, dann weist man dem Zeiger eine neue Adresse zu. Richtig? Trotzdem etwas verwirrend...

Bei char* const habe ich einen konstanten Zeiger auf ein char. Somit kann die Adresse nicht mehr veraendert werden, weil der Zeiger konstant ist - aber der Wert der Variablen, worauf der Zeiger zeigt schon:

char* const ZeigerAufZeichen = &einZeichen;

	*ZeigerAufZeichen = 'o';

Ich denke mal das habe ich alles richtig verstanden.
char const* const ist jetzt wohl ein Konstanter Zeiger auf ein konstantes Zeichen. Hier laesst sich weder die Adresse noch der Wert der Variablen, worauf der Zeiger zeigt aendern.

Nur wie sieht es in der Praxis aus? Wann braucht man Zeiger und wann nicht? Wann sind Referenzen sinnvoller? Ich habe schon haeufig mit Referenzen gearbeitet und sehe jetzt nicht wirklich einen Sinn Zeiger zu benutzen.

Und vor allem verstehe ich nicht wofuer Zeiger gut sind die auf void zeigen. Damit kann man doch nichts anfangen - kein Wert zuweisen usw.

Thx fuer den Link. Der Artikel ist sehr interessant. Den werde ich mir gleich mal durchlesen. Ich hoffe, dann wird einiges klarer....

Danke nochmal fuer eure Hilfe

Gruss
Cartman

Nur wie sieht es in der Praxis aus? Wann braucht man Zeiger und wann nicht? Wann sind Referenzen sinnvoller? Ich habe schon haeufig mit Referenzen gearbeitet und sehe jetzt nicht wirklich einen Sinn Zeiger zu benutzen.

Wie gesagt. Das ist nicht so eindeutig und Punkt langer Diskussionen. Wenn du einmal ein paar pro/kontra hören willst, dann gib dich doch bitte auf die Suche. Das hatten wir hier mehr, als einmal..

Die Meinungen gehen auseinander und es gibt kein "richtig" oder "falsch".. Alles hat Vor/Nachteile. Die abwägen muss jeder für sich selber.

EDIT:
1. http://www.c-plusplus.net/forum/viewtopic-var-t-is-227477-and-start-is-30-and-postdays-is-0-and-postorder-is-asc-and-highlight-is-.html

2. http://www.c-plusplus.net/forum/viewtopic-var-t-is-231254-and-postdays-is-0-and-postorder-is-asc-and-start-is-0.html

Da gibt es sicher noch mehr, aber das waren die, die ich so auf die schnelle gefunden habe.. Und da sollten deine Fragen auch beantwortet werden.

Es gibt nur noch eine Sache, die ich nicht verstehe. Welche spezielle Bedeutung hat der Inkrementierungsoperator fuer Zeiger?

int zahl = 5;
	int* ptr = &zahl;

	*ptr+=1; // zahl wird zu 6

int zahl = 5;
	int* ptr = &zahl;

	*ptr++; // etwas nicht verstaendliches passiert

Dazu habe ich nichts gefunden

Gruss
Cartman

int zahl = 5;
    int* ptr = &zahl;

    *ptr++; // etwas nicht verstaendliches passiert

in der operatorenpriorität steht ++ vor *, hilfreich ist da Dieser Link

das ganze inkrementiert den zeiger (der zeigt dann auf den wert, der im speicher
hinter der 5 steht), gibt dann den alten zeiger zurück (verhalten von ++) und
dereferenziert diesen dann. da man mit dem wert nix macht, kann der stern weg.

zu zeiger vs. referenzen (hab die links nicht durchgelesen)

da du eine referenz nicht umsetzen kannst, kannst du keine datenstrukturen
aufbauen oder durchwandern. z.b. zeichenketten:

wenn du nicht die stringklasse nimmst, kannst du nur schwer von einem zeichen
zum anderen wandern. mit zeigern muss man einfach nur +1 rechnen um den
nächsten buchstaben zu bekommen. guck dir mal <cstdio> an, alle funktionen
mit "str" am anfang arbeiten mit zeigern.

int main()
{
    const char *text = "Hallo!"; // zeigt auf 'H', der rest steht dahinter im speicher
    const char *p = 0; // zeigt auf nix

    p = text; // beide zeiger zeigen auf den selben string
    while (*p != 'l') // solange der INHALT (nicht wert) von p ungleich 'l' ist.
        ++p; // oder auch p++; // wird p auf den nächsten buchstaben gesetzt

    char x = *p; // x ist deshalb jetzt 'l'

    p = &x; // jetzt zeigt p auf unsere variable x, die den wert 'l' hat

    // *p ist deshalb 'l'

    *p = *text; // inhalt von text ('H') in den inhalt von p kopieren.

    // weil p auf x zeigt, ist x jetzt 'H'
}

void * zeiger werden in C++ eigenlich selten genutzt. entweder zum speichermanagemant
oder wenn z.b. eine funktion einer anderen funktion ein benuterdefinierten
wert übergeben soll, wobei die funktion natürlich nicht weiß, welchen wert.
(z.b. CreateThread)