Aber irgendwie versteh ich nicht was der damit genau in dem Tutorial meint, kann mir wer vielleicht erklären was da genau passieren soll.

Hier ist der Link vom Tutorial: http://www.cpp-tutor.de/cpp/le07/le07_01.htm

:xmas1: :xmas2:

// Funktionsdeklaration
void PrintHeader(int pageNum);
....
int main ( )
{
    // gleich noch Seitenueberschrift ausdrucken
    ....
    //
    ....
}
// Definition der PrintHeader-Funktion
void PrintHeader(int pageNum)
{
   cout << "Dies ist Seite " << pageNum << endl;
}

Such mal hier im C++ Forum nach dem Begriff "PrintHeader", es gab schon einige Threads bzgl. dieses Tutorials.

Die Funktion f(x)=x^2 zum Beispiel hat den Parameter x und gibt den Funktionswert an der Stelle x zurück.

pageNum wird so zu sagen umgewandelt in PrintHeader(4711);

is das so ungefähr richtig

#include <iostream>
using namespace std;

void PrintHeader(int pageNum);

int main ( )
{
PrintHeader(4711);     

getchar();
}

void PrintHeader(int pageNum)
{
   cout << "Dies ist Seite " << pageNum << endl;

}

ahh jetzt versteh ichs glaub ich

pageNum wird so zu sagen umgewandelt in PrintHeader(4711);

Fast - pageNum wird mit dem Wert (hier 4711) initialisiert, wenn deine Funktion aufgerufen wird.

Quellcode aus dem Tutorials

void PrintHeader (int pageNum);
....
int main ( )
{
    int pNum = 1;        // pNum initialisieren
    PrintHeader(pNum);   // Funktion aufrufen
    ...                  // pNum ist hier immer noch 1!
    PrintHeader(10);     // fixe Seitennummer
}
// Funktionsdefinition
void PrintHeader(int pageNum)
{
   cout << "Seiten-Nummer: " << pNum << endl;
   pageNum = 99;         // Parameter verändern
}

Quellcode aus dem Tutorial ohne Fehler:

#include <iostream>
using namespace std;

void PrintHeader (int pageNum);

int main ( )
{
    int pNum = 1;        // pNum initialisieren
    PrintHeader(pNum);   // Funktion aufrufen
                         // pNum ist hier immer noch 1!
    PrintHeader(10);     // fixe Seitennummer

    getchar();
}
// Funktionsdefinition
void PrintHeader(int pageNum)
{
   cout << "Seiten-Nummer: " << pageNum << endl;
   pageNum = 99;         // Parameter verändern
}

Weiss jemand wofür das hier steht: pageNum = 99; // Parameter verändern

als Kommentar steht dort ja Parameter verändnern ich hab mal die zahl von 99 auf 3 geändert aber da passiert ja gar nichts wofür soll denn dann das pageNum = 99; gut sein man kann es ja auch ganz weg lassen.

:xmas1: :xmas2:

In dem Beispiel-Code macht das sicherlich wenig Sinn, da die Variable danach nicht mehr benutzt wird (aber sie ändert auch nicht den Wert der übergebenen Variable, dies passiert erst bei Referenzen).

Hier vll. mal ein Beispiel für die Änderung des Funktionsparameters:

void printstars(int count)
{
  while(count > 0)
  {
    std::cout << '*';
    count--; // Parameter lokal verändern
  }
}

// Funktionsdefinition
void PrintHeader(int pageNum)
{
   cout << "Seiten-Nummer: " << pNum << endl;
   pageNum = 99;         // Parameter verändern
   cout << pageNum << endl; // Nach der Änderung
}

Dann siehst Du was passiert..

Jetzt bin ich bei der Called-by-value Parameter...

Was dir der Autor zeigen wollte ist, das der Wert selbst wenn du ihn in der Funktion änderst, bei Übergabe "Call-by-Value" nur innerhalb der Funktion geändert ist.

Ich werde es mal etwas näher erläutern, wobei ich wohl dem Tutorial vorgreife:
(Anmerkung: Code ist ungetestet)

#include <iostream>

void ChangeValue_CallByValue(int b);
void ChangeValue_CallByReference(int& b);

int main()
{
  int a = 4;
  std::cout << "Wert von a ist " << a << std::enld;
  ChangeValue_CallByValue(a);
  std::cout << "Wert von a ist " << a << std::enld;
  ChangeValue_CallByReference(a);
  std::cout << "Wert von a ist " << a << std::enld;

  return 0;
}

void ChangeValue_CallByValue(int b)
{
  b = 10;
  std::cout << "Wert vom Parameter b wurde innerhalb ChangeValue_CallByValue auf "
    << b << " geändert." << std::endl;
}

void ChangeValue_CallByReference(int& b)
{
  b = 20;
  std::cout << "Wert vom Parameter b wurde innerhalb ChangeValue_CallByReference auf "
    << b << " geändert." << std::endl;
}

Folgende Ausgabe sollte eigentlich kommen:

Wert von a ist 4
Wert vom Parameter b wurde innerhalb ChangeValue_CallByValue auf 10 geändert.
Wert von a ist 4
Wert vom Parameter b wurde innerhalb ChangeValue_CallByReference auf 20 geändert.
Wert von a ist 20

Dazu eine Erklärung:

In main() legst du eine Variable a an. Sprich du hast irgendwo im Speicher einen Bereich der den int Wert enthält und innerhalb von main() mit dem Namen "a" gültig ist. Am Ende deiner main() Funktion wird der Speicherbereich wieder gelöscht, da die Variable nur innerhalb des Bereiches in dem sie definert ist gültig ist.

Nun rufen wir ChangeValue_CallByValue auf und übergeben ihr a als Parameter. Wenn man aber genau hinter die Kulisen schaut wird hier wie der Name sagt nur der Wert übergeben.

a (aus main) ist 4.
==> Übergabe des Wertes an den ersten Parameter
b (aus ChangeValue_CallByValue) wird mit dem Wert von a (4) initialisiert, ist aber eine eigene Variable.

Das heißt eine Änderung an diesem Parameter ändert auch nur den Wert des Parameters, der am Ende der Funktion seinen Scope verlässt.

Daher liefert die main-Funktion anschließend auch wieder das a den Wert 4 hat.

Nun rufen wir ChangeValue_CallByReference auf. Das int& definiert keinen Wert in dem Sinne, sondern nur einen Aliasnamen (einen alternativen Namen für die übergebene Variable):

a (aus main) ist 4.
==> Übergabe als Referenz
b (aus ChangeValue_CallByReference) ist ein Aliasname für a (aus main)

Wenn du nun innerhalb der Methode b veränderst ist dies eine Änderung an der gleichen Variable, nur unter einem alternativen Namen (Die Namen können dabei auch beide identisch gewählt sein).

cu André

Jetzt guck ich mir gerade in dem Tutorial das Beispiel an:

#include <iostream>
#include <cmath>
using std::cout;
using std::endl;

// PrototyPIKng
double BerechneSin(double wert);

int main()
{
    // Konstante PIK definieren
    const double PI = 3.1416;

    // Berechne Sinus(0.5) mittels Reihe
    cout << "sin(0.5) : Berechnet = " << BerechneSin(0.5);
    // Und nun Sinus(0.5) mittels Bibliotheksfunktion
    cout << ", Bibl-Funktion = " << sin(0.5) << endl;
    // Das ganz nun fuer PI (3.1416);
    cout << "sin(PI)  : Berechnet = " << BerechneSin(PI);
    cout << ", Bibl-Funktion = " << sin(PI) << endl;
    // und zum Schluss fuer PI/2
    cout << "sin(PI/2): Berechnet = " << BerechneSin(PI/2.0);
    cout << ", Bibl-Funktion = " << sin(PI/2.0) << endl;
}

// Funktion: BerechneSin
//           Berechnet Sinus mittels Reihe
//              sin(x) = x - x^3/3! + x^5/5! - x^7/7!
// Parameter wert: Wert aus dem Sinus berechnet werden soll
double BerechneSin(double wert)
{
    // Ergebnis mit dem Wert vorinitialisieren
    // 1. Term in der Reihe
    double erg = wert;
    // Divident (Nenner) mit wert^3 vorbelegen
    double divident = wert*wert*wert;
    // Divisor (Teiler) 3! vorbelegen
    double divisor = 1.0*2.0*3.0;       // 3!
    // Zweiten Term vom Ergebnis subtrahieren
    erg -= divident/divisor;
    // Dritten Term zum Ergebnis addieren
    divident *= wert*wert;              // wert^5
    divisor *= 20.0;                    // 3! * 4 * 5 = 5!
    erg += divident/divisor;
    // Vierten Term wieder vom Ergebnis subtrahieren
    divident *= wert*wert;              // wert^7
    divisor *= 42.0;                    // 5! * 6 * 7 = 7!
    erg -= divident/divisor;
    // Ergebnis zurückliefern
    return erg;
}

und wenn ich das Compiliere bekomme ich folgende Fehlermeldungen.

Erzeugen
[C++ Fehler] Unit1.cpp(17): E2268 Aufruf der undefinierten Funktion 'sin'
[C++ Fehler] Unit1.cpp(20): E2268 Aufruf der undefinierten Funktion 'sin'
[C++ Fehler] Unit1.cpp(23): E2268 Aufruf der undefinierten Funktion 'sin'

Schon zweite Fehler in dem Tutorail

ps. Hat vielleicht wer ein beispiel wo nur Addiert und Subtrahiert wird ich habs net so mit Mathe ^^

Zur Erklärung: Die von C geerbten Standard-Header existieren in zwei Varianten in C++ - <math.h> packt alle enthaltenen Funktionen in den globalen Namensraum, <cmath> in den Namensraum 'std' (genau wie die eigenen Standardheader von C++).