const

Hallo erstmal, ich bin ein Anfänger in Sachen C++
Ich hab schon viele Funktionen gesehen die in den Parametern const stehen hatten.
Ich schreibs immer ungefähr so

void funktion(char *t)
{
    //Tu irgendwas
}

Was ist denn da der Unterschied dazu

void funktion(const char *t)
{
    //Tu irgendwas
}

Oder gibts da überhaupt keinen Unterschied?

Fake oder Echt

const heißt Konstant, also unveränderbar. Aber in deinem Zusammenhang, ist es egal, da char* intern als const char* gehandhabt wird.

Also ist es nur zur Sicherheit, dass die Variable nicht aus Versehen geändert wird. Oder gibt's da noch einen anderen Grund?

CodeFinder

BitWax schrieb:

const heißt Konstant, also unveränderbar. Aber in deinem Zusammenhang, ist es egal, da char* intern als const char* gehandhabt wird.

WTF?! Das ist ja totaler Schwachsinn... .

Im 1. Beispiel, kannst Du den Inhalt, auf den mit 't' zugegriffen wird, verändern; im 2. Beispiel geht das nicht . Man sollte -wenn möglich/sinnvoll- die 2. Möglichkeit bevorzugen.
EDIT: Oder noch besser: Man verwendet die Klasse std::string .
(Und übergibt dann so:

void foo(std::string& strParam) { /* ... */ }

bzw. so:

void foo(const std::string& strParam) { /* ... */ }

); also per Referenz.

Badestrand

EinAnfänger... schrieb:

Also ist es nur zur Sicherheit, dass die Variable nicht aus Versehen geändert wird. Oder gibt's da noch einen anderen Grund?

Genau das ist es, ist aber ein wirklich großer Vorteil! In seinen Programmen will man ja Bugs vermeiden und die sogenannte const-correctness von C++ ist ein wichtiges Konzept, wo vornherein Bugs ausgeschlossen werden.

Das ganze soll darauf hinauslaufen, ganz wie du schon erkannt hast, dass deine Variablen nicht einfach so verändert werden. Das klappt aber nicht nur mit normalen Variablen wie chars oder ints, sondern auch mit Klassen. Wenn eine Funktion einen Zeiger auf eine konstante Klasse entgegennimmt, kann sie auch nur die Methoden der Klasse aufrufen, die als "const" markiert sind:

// Du hast folgende Klasse:
class MeineKlasse
{
    public:
        void SetzeWert( int wert ) // Wird verändert
        {
            mein_wert = wert;
        }

        int VergreossereWert() // Wird verändert
        {
            mein_wert += 5;
        }

        int BekommeWert() const // Keine Variable der Klasse wird verändert
        {
            return mein_wert;
        }

    private:
        int mein_wert;
};

// Und so eine Funktion:
void MacheIrgendwas( const MeineKlasse* zeiger )
{
    zeiger->VergroessereWert(); // Klappt nicht, da nicht const
    int wert = zeiger->BekommeWert();
}

Und das geht sogar soweit, dass du nicht einfach hinter irgendeine Methode in deiner Klasse "const" schreiben kannst - wenn du darin eine Variable der Klasse änderst, merkt das der Compiler und du darfst die Methode nicht als const deklarieren.

Das gibt dir oft ein gutes Gefühl im Bauch. Sagen wir mal du programmierst mit deinem Kumpel zusammen irgendwas. Der entwirft eine Funktion wie die oben, die einen Zeiger auf "MeineKlasse" entgegennimmt. Und du hast in deinem Code eine Instanz (=Variable) der Klasse und rufst damit die Funktion auf.
Wenn dein Kumpel sagt, er verändert die Klasse in seiner seiner Funktion nicht, dann kannst du ihm vertrauen, ooooder aber du sagst ihm, er soll (wie oben) in seiner Funktion angeben, dass die Klasse nicht verändert werden darf ("const MeinKlasse* zeiger").

So, wenn du nun ein Objekt deiner Klasse hast, weißt du dann, dass es nach dem Funktionsaufruf unverändert ist, und eben das ist oft ungeheuer wichtig

MeineKlasse meins;
meins.SetzeWert( 100 );
meins.VergreossereWert();
// Die Variable "mein_wert" in "meins" ist jetzt 105
MethodeVonDeinemKumpel( &meins );
// Und hier ist die Variable garantiert immer noch 105, ist das nicht schön? :)

Anstatt dass dein Kumpel Code schreibt, kannst du dir auch einfach vorstellen, dass du selber mal ne Funktion geschrieben hast (vor langer Zeit) und du gar nicht mehr genau weißt, ob sie den Parameter verändert oder nicht. Deshalb lieber kein Vertrauen sondern Kontrolle per const - aber halt überall da, wo das Objekt nicht verändert werden soll.

pumuckl

Oder du benutzt statt code von deinem Kumpel eine Bibliothek, von der du nur die Header kennst. Wenn dir die Deklarationen der Funktion zusichern, dass sie das Objekt nicht verändern, kannst du dich darauf verlassen und musst nicht mit bösen Überraschungen durch Nebeneffekte rechnen.

Fake oder Echt

CodeFinder schrieb:

BitWax schrieb:

const heißt Konstant, also unveränderbar. Aber in deinem Zusammenhang, ist es egal, da char* intern als const char* gehandhabt wird.

WTF?! Das ist ja totaler Schwachsinn... .

Im 1. Beispiel, kannst Du den Inhalt, auf den mit 't' zugegriffen wird, verändern; im 2. Beispiel geht das nicht . Man sollte -wenn möglich/sinnvoll- die 2. Möglichkeit bevorzugen.
EDIT: Oder noch besser: Man verwendet die Klasse std::string .
(Und übergibt dann so:
void foo(std::string& strParam) { /* ... */ }
bzw. so:
void foo(const std::string& strParam) { /* ... */ }
); also per Referenz.

hmmm...sry, war glaube ich zu sehr mit meinem tut beschäftigt