ich bin beim oben genannten Thema etwas verwirrtbzw verstehe wohl mein Buch nicht so gänzlich. Auch die Internet Lektüre half mir nicht.

Nehmen wir folgende Funktion:

// Fig. 6.18: fig06_18.cpp
// Using an inline function to calculate the volume of a cube.
#include <iostream>
using std::cout;
using std::cin;
using std::endl;

// Definition of inline function cube. Definition of function appears 
// before function is called, so a function prototype is not required. 
// First line of function definition acts as the prototype.
inline double cube( const double side ) 
{ 
   return side * side * side; // calculate cube
} // end function cube

int main()
{
   double sideValue; // stores value entered by user 
   cout << "Enter the side length of your cube: ";
   cin >> sideValue; // read value from user

   // calculate cube of sideValue and display result
   cout << "Volume of cube with side " 
      << sideValue << " is " << cube( sideValue ) << endl;
   return 0; // indicates successful termination
} // end main

/**************************************************************************
 * (C) Copyright 1992-2008 by Deitel & Associates, Inc. and               *
 * Pearson Education, Inc. All Rights Reserved.                           *
 *                                                                        *
 * DISCLAIMER: The authors and publisher of this book have used their     *
 * best efforts in preparing the book. These efforts include the          *
 * development, research, and testing of the theories and programs        *
 * to determine their effectiveness. The authors and publisher make       *
 * no warranty of any kind, expressed or implied, with regard to these    *
 * programs or to the documentation contained in these books. The authors *
 * and publisher shall not be liable in any event for incidental or       *
 * consequential damages in connection with, or arising out of, the       *
 * furnishing, performance, or use of these programs.                     *
 **************************************************************************/

Ein call-by-reference funktioniert ja so, dass ich eine funktion mit einer Variable als Parameter aufrufe

<< sideValue << " is " << cube( sideValue ) << endl;

und diese Funktion in ihrer Deklaration eine Variable als Argument definiert hat

inline double cube( const double side )

Wenn ich es richtig sehe, sind ja bei einem Aufruf mit call per referencedie Originalvariablen, in diesem Fall sideValue ohnehin geschützt.

Wozu brauche ich nun also das "const" in der Deklaration der Funktion cube, wenn die original variable ohenhin nicht verändert wird?

...Ein call-by-reference funktioniert ja so, dass ich eine funktion mit einer Variable als Parameter aufrufe

Erstmal bringen wir Begriffe ins Loot:

Call By Referenz: Aufruf mit einer Referenz (Aliasname) einer Variable
Call By Value: Aufruf mit einer Kopie einer Variable

// a) Call by Value
//    (Arbeit mit Kopie die verändert werden kann ohne Original zu ändern)
void foo1(int value);
// b) Call by Referenz
//    (Arbeit mit Referenz, jede Veränderung betrifft das Original)
void foo2(int& value);
// c) Call by const Value
//    (Arbeit mit Kopie die nicht verändert werden kann)
void foo3(const int value);
// d) Call by const Referenz
//    (Arbeit mit Referenz die nicht verändert werden kann)
void foo4(const int& value);

Ich hoffe mehr Durchblick... Weil dein Beispiel ist schonmal nicht Call by Reference

cu André
P.S: Konstante Parameter ob Value oder Referenz sind nicht zwangsweise Unsinn. Erstens soll ein Compiler mit konstanten Werten eher optimieren können, zweitens vermeidest du so Logikfehler (Ohne const könntest du ihn dir zwischen den Zugriffen ändern und übersiehst es bei späterer Benutzung)

call by reference (non-const) bedeutet für den Klienten: in dieser Funktion wird dein Wert verändert (sonst hätte es const ref heißen müssen und wäre schlechtes design)
alles andere bedeutet für den Klienten: keine Panik, dein Wert wird nicht geändert.

call by value (non-const) heißt für den Implementierer: du hast hier eine Kopie des übergebenen Wertes, mach damit was du willst.

call by const reference und call by const value hingegen bedeutet, dass der Implementierer nichts ändern darf. Call by const value macht nur dann Sinn, wenn das Anlegen einer Referenz teurer ist als das Anlegen einer Kopie. Da Referenzen intern oft die Größenordnung eines Zeigers haben sagt man, dass eingebaute Typen, evtl. bis auf doubles oder lng doubles, per value übergeben werden (wenn man denn Wert drauf legt const), alles andere per const reference. Übergaben per const value können Compiler meines Wissens gegen eine const reference tauschen zum optimieren, wenn der Copy-Ctor der übergebenen Klasse hinreichend trivial und frei von Nebeneffekten ist.

hm mir ist immer noch nicht ganz klar, wozu ich const im Kontext mit call-by-value benutzen sollte

Außerhalb der Funktion nutzt es nichts. Innerhalb der Funktion schon, weil man dadurch Fehler vermeidet, wenn man z.B. aus Versehen der Variablen einen Wert zuweist, was man gar nicht machen wollte, dann meldet der Compiler einen Fehler.

Es gibt Sprachen (z.B. Nemerle), da ist *jeder* Wert 'const', wenn man ihn nicht explizit als 'mutable' deklariert. Finde ich sehr sympatisch, diesen Ansatz, denn normalerweise ändert sich eine Variable nicht mehr, nachdem man ihr einmal einen Wert verpasst hat.

normalerweise ändert sich eine Variable nicht mehr, nachdem man ihr einmal einen Wert verpasst hat.

Das ist aber ein bisschen wiedersprüchlich, nicht?

Konrad Rudolph schrieb:

normalerweise ändert sich eine Variable nicht mehr, nachdem man ihr einmal einen Wert verpasst hat.

Das ist aber ein bisschen wiedersprüchlich, nicht?

Häng Dich nicht an den Vokabeln auf, es sollte doch klar sein, was ich meinte. Nenn es halt „Wert“ statt „Variable“.

drakon schrieb:
Konrad Rudolph schrieb:
normalerweise ändert sich eine Variable nicht mehr, nachdem man ihr einmal einen Wert verpasst hat.

Das ist aber ein bisschen wiedersprüchlich, nicht?

Häng Dich nicht an den Vokabeln auf, es sollte doch klar sein, was ich meinte. Nenn es halt „Wert“ statt „Variable“.

Hab ich nicht vor, aber ich meinte eher, dass wenn ich Variabeln/Werte habe, dann
brauche ich die auch und ändere die entsprechend auch und das eigentlich nicht gerade wenig, im Allgemeinen. Vor allem das "Normalerweise", finde ich, weckt ein
wenig falsche Vorstellungen.

Konrad Rudolph schrieb:

normalerweise ändert sich eine Variable nicht mehr, nachdem man ihr einmal einen Wert verpasst hat.

… wenn ich Variabeln/Werte habe, dann
brauche ich die auch und ändere die entsprechend auch und das eigentlich nicht gerade wenig, im Allgemeinen. Vor allem das "Normalerweise", finde ich, weckt ein
wenig falsche Vorstellungen.

Hmm. Dann solltest Du Dir mal Deinen Code genau anschauen. Bedenke, dass jede Variable genau *einen* Zweck erfüllen sollte und nicht recycled wird. Unter diesen Voraussetzungen gibt es eigentlich nur drei Arten von Variablen, die man überhaupt ändert (normalerweise, Ausnahmen gibt's immer):

– Zählvariablen in Schleifen,
– Aggregatoren (also Variablen, die Zwischenergebnisse speichern), und
– Container.

Alle anderen Variablen sind temporäre Werte, die man häufig nur ein einziges Mal schreibt und auch oft nicht häufiger liest, die also nur der Übersichtlichkeit (oder Effizient) in Variablen wegen zwischengespeichert werden.

Mengenmäßig machen diese Variablen in sauberem Code einen großen Teil aus (vor allem in Sprachen, in denen man mehr Rekursion als Iteration verwendet, aber auch in anderen). Und all diese Variablen könnten Konstanten sein.

Du magst recht haben, in C++ ist das „normalerweise“ evtl. nicht ganz richtig, da man in C++ überdurchschnittlich häufig Variablen der oben aufgezählten Arten benötigt. Trotzdem sind es in meinen Codes schätzungsweise 60%. Und je mehr man kapselt, desto mehr werden es, weil dadurch immer mehr Aggregatoren und Zählvariablen wegfallen.

Und dort gibt es relativ viele Variabeln, die ihren Wert im Laufe der Zeit
ändern. (Zeit, Punkte, Geschwindigkeit, Namen, Zustandswerte...)

Und da soo viele Zeilen in C++ für Games geschrieben werden, wird hier
die "Normalität" wohl eher bei variablen Variabeln liegen.

Aber ich denke mal, du hast in sonstigen Programmen schon recht.

Also ich beziehe mich jetzt auf Spieleprogrammierung.

Also das spielt jetzt nun doch ganz und gar keine Rolle.
Nein, wirklich nicht!
Simon

Also ich beziehe mich jetzt auf Spieleprogrammierung.

Und dort gibt es relativ viele Variabeln, die ihren Wert im Laufe der Zeit
ändern. (Zeit, Punkte, Geschwindigkeit, Namen, Zustandswerte...)

Und da soo viele Zeilen in C++ für Games geschrieben werden, wird hier
die "Normalität" wohl eher bei variablen Variabeln liegen.

Aber ich denke mal, du hast in sonstigen Programmen schon recht.

Diese Werte hat man aber normalerweise (*g*) auch in Membervariablen vorliegen und nicht in lokalen Variablen. Und wenn ich ihn richtig verstehe dann hat Konrad schon lokale Variablen gemeint.

Aber er hat das im Zusammenhang einer anderen Programmiersprache gesagt und
ich habe es so im allgemeinen verstanden.