vielleicht könnt ihr mir helfen.

Ich muss zu Morgen diese beiden Programme erläutern können (Schreiben eine Arbeit), und habe darüber nicht wirklich Ahnung, was auch am Lehrer liegt.

Was ich weiß, was "Call by Value, Call bei Referenz und Call bei Pointer" bedeutet." Doch das drumherum kapiere ich leider nicht.

das Programm

*//Parameteruebergabe

//Praeprozessordirektive
#include<iostream.h>

//Deklaration
void tauscheV(int, int); //Call by Value
void tauscheR(int &, int &); //Call by reference
void tauscheP(int *, int *); //Call by pointer

//Hauptprogramm

void main()
{
int nA=5, nB=7;
cout<<"Variationen von \"tausche\""<<endl;
cout<<'a'<<'\t'<<'b'<<endl;
cout<<nA<<'\t'<<nB<<endl;

cout<<"\n\ntauscheV\n";
tauscheV(nA,nB);
cout<<nA<<'\t'<<nB<<endl;

cout<<"\n\ntauscheR\n";
tauscheR(nA,nB);
cout<<nA<<'\t'<<nB<<endl;

cout<<"\n\ntauscheP\n";
tauscheP(&nA,&nB);
cout<<nA<<'\t'<<nB<<endl;
}

//Implementation

void tauscheV(int nX,int nY)
{
int nH=nX;
nX=nY;
nY=nH;
}

void tauscheR(int & nX,int & nY)
{
int nH=nX;
nX=nY;
nY=nH;
}

void tauscheP(int * nX,int * nY)
{
int nH= * nX;
* nX= * nY;
* nY=nH;
}*

Und dieses Programm*

// Referenzenzeiger

struct tPunkt
{
int nXpos;
int nYpos;
char cFarbe;
bool bSichtbar;
};

void main()
{
int nA;
nA=5;
// Referenz
int & rnB = nA; // rnB Referenz auf int, rnB alias für nA
rnB = 7;
rnB++;
nA++;

// Zeiger
int * pnC; // pnC ist ein Zeiger auf int
pnC=& nA; // pnC erhält die Adresse von nA
*pnC=10; // der Inhalt des Speicherplatzes auf den pnC zeigt, wird auf 10 gesetzt
pnC++; // Zeiger wird um vier erhöht, da der Datentyp int 4 Byte hat

/////////////////////////////////////////////////////////
tPunkt stP;
stP.nXpos=3;
stP.nYpos=5;
stP.cFarbe='A';
stP.bSichtbar=true;
// Referenz
tPunkt & rstP1=stP;
rstP1.nXpos=33;
// Zeiger
tPunkt pstP2;
pstP2=&stP;
pstP2->nXpos=333;
pstP2++;
}

#include <iostream> // #include <iostream.h> ist nichtmehr korrekt

void switch_values(int, int);		// Call by Value
void switch_references(int&, int&); // Call by reference
void switch_pointers(int*, int*);	// Call by pointer

// Programmeinsprungspunkt (nach std.)
int main()
{
	int nA = 5;
	int nB = 7;
	std::cout << "Variationen von \"switch\"" << std::endl; // cout und endl liegen im std namespace
	std::cout << "a\tb" << std::endl;						// "a	b" ausgeben
	std::cout << nA << '\t' << nB << std::endl;				// Wert von nA und nB durch TAB getrennt ausgeben

	std::cout << "\"switch\" by value" << std::endl;		// " "switch" by value" ausgeben
	switch_values(nA, nB);									// den Wert von nA und nB an switch_values übergeben.
	std::cout << nA << '\t' << nB << std::endl;				// Wert von nA und nB durch TAB getrennt ausgeben. 
															// Da die Funktion nicht auf nA oder nB direkt zugreift, 
															// bleibt die Ausgabe gleich.

	std::cout << "\"switch\" by reference" << std::endl;	// " "switch" by reference" ausgeben
	switch_references(nA, nB);								// Eine Referenz von nA und nB an die Funktion übergeben
	std::cout << nA << '\t' << nB << std::endl;				// Der Wert von nA ist nun 7 und von nB ist er 5

	std::cout << "\"switch\" by pointer" << std::endl;		// " "switch" by pointer" ausgeben
	switch_pointers(&nA, &nB);								// Zeiger auf nA bzw nB der Funktion übergeben (Zeigt auf 
															// die Adresse der Variablen)
	std::cout << nA << '\t' << nB << std::endl;				// nA = 5 und nB = 7
}

void switch_values(int nX, int nY)
{
	int nTemp	= nX;										// Wert von nX in einer temporären(lokalen) Variable nTemp speichern
	nX			= nY;										// nX den Wert von nY zuweisen
	nY			= nTemp;										// nY den Wert der temporären Variable nTemp zuweisen
															// Die Funktion wird wahrscheinlich wegoptimiert, da effektiv kein 
															// Unterschied bei den Variablen vor und nach dem Funktionsaufruf 
															// festzustellen ist.
}

void switch_references(int& nX, int& nY)
{
	int nTemp	= nX;										// Wert von nX in einer temporären (lokalen) Variable nTemp speichern
	nX			= nY;										// Der Referenz nX wird der Wert von der Referenz nY zugewiesen
	nY			= nTemp;									// Der Referenz nY wird der Wert der temporären (lokalen) Variable nTemp
															// zugewiesen
}

void switch_pointers(int* nX, int* nY)
{
	int nTemp	= *nX;										// Wert bei der Adresse auf die nX zeigt, wird in einer temporären (lokalen) 
															// Variable nTemp gespeichert
	*nX			= *nY;										// Der Wert auf den nX zeigt wird auf den Wert auf den nY zeigt geändert
	*nY			= nTemp;									// Der Wert auf den nY zeigt wird auf den Wert der temporären (lokalen) 
															// Variable nTemp gesetzt
}

Von einen Tellerstapel nimmt man gewöhnlich immer den obersten Teller.

Aktuelle Parameter - also diejenigen die beim Aufruf einer Funktion ind den "()" stehen - werden auch auf einen Stapel aka. Stack abgelegt und die aufrufende Funktion holt sich die Teller, pardon Parameter, von dort.
Wenn sie fertig ist wirft sie die Teller, sprich Paramter aber nicht auf den Stapel zurück sondern wirft sie weg ( jedenfalls so ungefähr ) und der Stapel wird kleiner.

Bei V) wird ein neuer Teller au den Stapel gelegt ( eine Kopie ).
Mit der kann man anstellen was man will, am Ende geht der zu Scherben.
Zuvor wird aber eine neue Kopie von i++ angelegt ( von "return" ) und "woanders gespeichert.
Wo ist jetzt egal - zurückgegeben wird nicht die Kopie i vom Stapel, auch nicht iRetVal sondern eine Kopie von iRetVal.
Der Rest sind Scherben.

Bei R) wird nur ein neuer Name für ein int erzeugt; incRefVal spricht das Originalobjekt unter diesem neuen Namen ("Pamela" => "Pam") an und kann es verändern.
Der Teller der zum Schluss zerbricht ist nur der neue Name.
Den neuen Namen erzeugt überigens der Compiler weil er in der Funktionsdeklaration mittel int& darum gebeten wird.
Man könnte auchzuvor einen Namen fur j ermitteln und den übergeben

int& ikRef = k;

Aber dann wären's zeitweilg drei und nicht zwei Namen für das gelche Ding.

Bei P) ganz ähnlich, nur wird hier kein Name sondern eine (konstante) Zahl übergeben, nämlich die Adresse eines int.
Über die Adresse kann incPtrVal das originale Objekt so ähnlich ansprechen wie mit einer Referenz; zum Schluß wird nur der Teller mit dwer Konstanten weggeworfen.
Die Adresse wird hier mittels &i im Funktionsaufruf ermittelt.
Das ginge auch in zwei Schritten:

int* pk = &k;
incPtrVal(pk);

int& ist ein Typ, nämlich ein Referenz auf ein int.
&k ist ein Ausdruck, der zur Adresse von k ausgewertet wird.

Grüsse

*this

Achja ... dein Lehrer ... hat der was gesagt warum er dieses "n" usw. vor die Variablennamen packt? Sowas von wegen Ungarischer Notation ...? Dann hat der da aber eine Wissenslücke

Ja deswegen schreibt er das.

(D)Evil,

vielen vielen Dank. Das hilft mir echt weiter, auch zu beseren Verständniss.

Ich hatte schon mal eine ähnliche Antwort bekommen, dass man include <iostream.h> nicht mehr verwendet, doch dann sagte mein Lehrer " Ach Quatsch, das stimmt doch nicht..." Kein Wunder, dass ich ne 5 bisher bei ihm habe. -.- Aber nochmals vielen Dank dir dafür und auch allen anderen!

First, the .h notation of standard header files was deprecated more than 5 years ago.

the rock 100 schrieb:

Ich hatte schon mal eine ähnliche Antwort bekommen, dass man include <iostream.h> nicht mehr verwendet, doch dann sagte mein Lehrer " Ach Quatsch, das stimmt doch nicht..."

Also bei sowas bekomme ich echt zu viel. Da sieht man mal wie "gut" unser Bildgungssystem ist. Irgendein alter Lehrer bringt noch 30 Jahre nach seiner eigenen Ausbildung den Schülern den alten Kram bei. Sowas darf doch einfach nicht sein! Dass die Lehrer nicht dazu verpflichtet sind sich weiter zu bilden.
Aber das schlimmste ist noch, dass sich viele Lehrer nichts sagen lassen und somit immer noch den alten Kram unterrichten und sie meinen auch noch dass dies richtig sei. pfff, da fällt einem echt nichts zu ein
Ist kein Wunder, wenn Deutschland bei den ganzen Studien immer schlecht abschneidet.

Sag mal, the rock 100, ist das ein Prof an einer Uni oder ein Lehrer an einer Schule? Ein Prof kann ich mir ja fast nicht vorstellen, aber möglich ist heute ja alles

Aber Sorry, das gehört ja eigentlich nicht ins C++ Forum.

Gruß Spartaner

Diese Notation ist die Abwandlung der microsoft’schen Windowsprogrammierer und entspricht nicht mehr dem Sinn, den Simonyi bei der Entwicklung der ungarischen Notation verfolgt hat.