[Beginner] Frage zu Variablennamen und Funk-Parametern

Falke88

Hallo Leute,

Ich arbeite gerade seit 1 Woche mit C++ und lerne es mit dem eBook "C++ für Spieleprogrammierer" von Heiko Kalista. Ich finde das Buch erste Sahne und verstehe meist alles zu 100%.

Jedoch bin ich gerade im Kapitel "Überladene Funktionen" angelangt - wo ein Beispiel genannt wird - welches noch NICHTS mit den besagten Funktionen zu tun hat. Es ist einfach ein Beispiel welches im Moment noch so wie es da steht richtig ist - man es aber bei Anwendungen von float UND int Datentypen zu einer überladenen Funktion umwandeln sollte.

Ok ich erzähle hier wohl keinem was neues ich komme zu meinem Problem.
Es geht hier um das Verständnis des Beispieles. Das Beispiel wurde gezeigt aber beim durchlesen habe ich selbst einige Dinge endeckt die mich zum grübeln bringen und zu denen ich bei der Erklärung und den vorherigen Artikeln leider keine Lösung zu finde.

Hier der Quellcode:

#include <iostream>

using namespace std;

bool testeBereich (int Position, int Min, int Max); // Prototyp

int main ()
{
	int Minimum = 0;
	int Maximum = 800;
	int xPosition;

	cout << "Spielerposition auf der x-Achse: ";
	cin >> xPosition;

	if (testeBereich (xPosition, Minimum, Maximum) == true)
		cout << "Spieler ist noch auf dem Bildschirm" << endl;
	else
		cout << "Spieler ist ausserhalb des Bildschirms" << endl;

	return 0;
}

bool testeBereich (int Position, int Min, int Max)
{
	if ((Position >= Min) && (Position < Max))
		return true;
	else
		return false;
}

So, dass sieht für euch bestimmt alles in Ordnung aus, nur wundern mich einige Dinge bei denen ich gedacht habe das mir der Compiler paar Fehlermeldungen an den Kopf wirft. Der Compiler lief aber ohne Probleme durch.

Oben im Prototypen der Funktion werden die Funktionsparameter "int Position, int Min und int Max) erwähnt. Diese Variablen erscheinen dann auch am Ende im Code-Block der Funktion.

Der Hauptteil jedoch deklariert und definiert die Variablen:
int Minimum = 0
int Maximum = 800 und
int xPosition

Wenn diese Variablen nun auf den Stack gelegt werden und von der Funktion unten wieder entnommen werden dann verstehe ich nicht wie die Funktion fehlerfrei z.B. die Original-Variable "Minimum" für die in der "if"-Bedingung verwendete Variable "Min" halten kann und damit "rechnet". Das Gleiche bei "xPosition" welche einfach als "Position" erkannt wird und ebenfalls in die Bedingungsrechnung eingebunden wird.

Meine Verwunderung ist halt wie die Funktion denn wissen kann das mit "Min" die Variable der Main-Funktion "Minimum" gemeint ist".
Ich kann doch nicht einfach im Parameter "Affenfurz" eingeben und die Funktion später weiss dann das es der Parameter "Reissack" ist.

Außerdem gibt die if-Funktion den Namen der Funktion doch falsch an.
Sie schreibt beschreibt einfach:
if (testeBereich (xPosition, Minimum, Maximum)
wobei ich im Prototypen und der Name der Funktion unten ja immernoch:
bool testeBereich (int Position, int Min, int Max)
lautet...

*Nagut irgendwie schwirrt mir jetzt selber eine Erklärung im Kopf herum.
Die Parameter bei der Prototyp bzw. Funktionsangabe selbst sollen anscheinend nur Platzhalter für die Reihenfolge sein bzw. auch einen immer wieder erkennbaren Namen zu den Variablen haben die später darüber geleitet werden.
*

---

Nunja bevor ich das Ganze hier versuche mir selbst zu erklären und 1-2 Denkfehler trotzdem noch einbaue die mich hier ins Forum wieder zurückzaubern, lass ich euch lieber nochmal ran - insofern ich das Ganze nicht doch schon richtig verstanden habe.

gruß Falke

*rT*f*Ct

es ist völlig egal wie die Variablen in einer Funktion heisen, der Typ ist wichtig.
als Prototyp reicht zB die Deklaration

BOOL testeBereich (int , int , int );

du kannst beim Prototype aber auch schreiben

BOOL testeBereich (int a, int b, int c);

und bei der auflösung der Funktion wieder ganz andere Variablen namen verwenden

bool testeBereich (int c, int b, int a)
{
}

dein programm wird weiterhin fehlerfrei arbeiten, (macht man aber nicht, da es einen selbst verwirrt)

auch ist es unwichtig wie die Variable heist, die du an die Funktion übergibst, wichtig ist nur das sie von dem gleichen oder artverwanten Typ ist wie die Variable in der Funktion an der du den wert übergibst.

du könntest an die Funktion

testeBereich (int Position, int Min, int Max)

an die Variable Position auch Variable Min oder Max übergeben, das einzige was passiert ist das die funktion falsch rechnet.

die Variablen und deren spezieller name hat nur den sinn, das du weist was du an welcher steller der funktion übergeben must, und werte nicht ausversehen vertauschst, da ansonsten die funktion nicht o. nicht korrect arbeitet.

Falke88 schrieb:

dann verstehe ich nicht wie die Funktion fehlerfrei z.B. die Original-Variable "Minimum" für die in der "if"-Bedingung verwendete Variable "Min" halten kann und damit "rechnet".

das ist, wie wenn du in der Schule definierst:

f(t) = t^2

und dann f(4) ausrechnest - der formale Parameter t wird mit 4 belegt, und f rechnet 4^2 = 16 aus.

Wenn du vorher die Variable

s = 4

definierst und f(s) ausrechnest, wird beim Aufruf von f(s)
die Belegung t = s gemacht und t^2 ausgerechnet - Ergebnis ist s^2, also 4^2 = 16.

Ähnlich ist es hier auch - wie du die Parameter Position, Min, Max im Funktionskopf von testeBereich benennst, ist prinzipiell egal - der Compiler erkennt anhand der Position der Argumente, welches Argument für welchen formalen Parameter bestimmt ist, und macht beim Aufruf

testeBereich (xPosition, Minimum, Maximum)

die Zuweisung
Position <-- 1. Argument (=xPosition)
Min <-- 2. Argument (=Minimum)
Max <-- 3. Argument (=Maximum)

Falke88

Ahhh ok moment...

man könnte also sagen das mathematische parameter wie a,b,c die bei f(a) auftauchen - bei C++ ganz einfach leere Zeilen sein können bzw. natürlich mind. den Dateityp voranzustellen haben.

also:

Funktion (int , int , int ,)

könnte bei der if Bedingung

if (Punkte, Ergebnis, Fleisch) sein - somit würde Punkte den ersten "Leerplatz" ersetzen und Ergebnis und Fleisch die 2 folgenden Plätze...

ok kapiert (wenn ichs jetzt richtig verstanden habe s.o.)

Ich bedanke mich bei der großen Hilfe !!!

drakon

Hehe. Jetzt wollte ich es gerade erklären.
Aber ich denke, dass du es jetzt verstanden hast. Die Namen, die du vergibst sind völlig egal. Sowie auch die Reihenfolge, wie du die Variablen anlegst, welche du übergibst. Beim Aufruf wird der Name der Variable einfach in eine Speicheradresse umgewandelt und dabei ist völlig egal, wo die genau liegt. Interessieren tut lediglich der Wert, der dort liegt.

man könnte also sagen das mathematische parameter wie a,b,c die bei f(a) auftauchen - bei C++ ganz einfach leere Zeilen sein können bzw. natürlich mind. den Dateityp voranzustellen haben.
Funktion (int , int , int);

Richtig. Darum ist es auch bei der Vorwärtsdeklaration von Funktionen völlig egal, wie die Parameter heissen. Und wenn dort Namen angegeben sind, dann "nur" für den Leser und überhaupt nicht für den Compiler. Bei der Definition hingegen sind die Namen wichtig, damit man auf sie zugreifen kann.

Das ist das schöne an Hochsprachen. Man muss sich um technische Dinge, wie die Reihenfolge auf dem Stack usw. gar keine Gedanken machen. Man kann einfach ganz intuitiv damit arbeiten.

Falke88

hehe Danke nochmal für die Bestätigung