3. const char* und char *const && allgemeine Fragen zu Zeigern

const char* und char *const && allgemeine Fragen zu Zeigern

  • E

    Hi!
    Ich versteh den Unterschied nicht ... 😞
    Wenn man die Adresse einer Variablen an const char* zuweist, kann kein neuer Wert an den Zeiger zugewiesen werden. Aber bei char *const geht das ohne Probleme. Wozu ist char *const dann jetzt gut? 😕

    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

    0
  • N

    Das const bezieht sich - wenn man es konsequent macht - auf das, was links davon steht.

    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.

    0
  • D

    Wenn du mal ganz intensiv hier im Forum suchst, wirst du auf scheinbar unendliche Diskussionen stossen, die sich mit Zeiger/Referenzen befassen.

    Ich sage jetzt mit Absicht nichts dazu. 😉

    0
  • N

    Warum schaut eigentlich niemand die Artikel an? Die scheinen richtig unbekannt zu sein...

    -> Link zu Artikel über Zeiger

    0
  • E

    Danke fuer eure Antworten!

    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

    0
  • D

    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.

    0
  • E

    Danke 🙂
    Jetzt ist mir einiges klarer geworden.

    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

    0
  • H

    Eric Cartman schrieb:

    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)

    0
Anmelden zum Antworten