Ich hab eine Aufgabe bekommen, ich hab sie auch soweit gelöst (Menu + Swap), aber mein Problem ist, die Aufgabe 1 & 2.

Und zwar ist bei mir der Fall, dass, egal welche Zahlen ich eingebe (!), immer derselbe Wert (Zeiger/Referenz) rauskommt (Bei mir im Code ist es die Funktion 2).
Und laut der Aufgabe soll das nicht so sein, oder?

Ich hab wirklich alles versucht,ich bin mit mein Wissen am Ende,....

Entweder kommt nicht das raus, was ich will oder es kommt immer ein Fehler (sobald ich versuche, es so zu ändern, wie es verlangt wurde).

Ich wäre euch sehr dankbar, wenn ihr mir helfen könntet.
Hier die Aufgabe:

Es soll ein Programm erstellt werden, in dem dann das
Verhalten von Variablen und zugehörigen Zeigervariablen mittels Funktionen demonstriert
werden soll. In dem Programm sind daher 2 Variable (z.B. a,b) eines ausgewählten Typs zu
deklarieren und geeignet zu initialisieren, sowie 2 Zeigervariable auf diesen Typ (z.B. pa und
pb), welche anfänglich auf die beiden Variablen verweisen.
Dann sind folgende Funktionen zu erstellen, wobei die Variablen bzw. Zeigervariablen als
Parameter zu übergeben sind (keine globalen Größen!!). Legen Sie jeweils die passende
Übergabetechnik (Call by Value/Reference) fest.

1. 2 Funktionen mit dem (gleichen) Namen inputValue zur Eingabe der Werte der beiden
   Variablen über Tastatur. Die eine Funktion hat dabei Referenzen als Parameter , die
   andere hat die beiden Zeigervariablen als Parameter.

2. 2 Funktionen mit dem (gleichen) Namen outputValue zur Anzeige der Werte der beiden
   Variablen am Bildschirn. Die eine Funktion hat dabei die Variablen selbst als Parameter,
   die andere hat die beiden Zeigervariablen als Parameter.

Das Programm main soll dann ein Menue enthalten, in welchem der Nutzer wiederholt eine der
Funktionen auswählen und aufrufen bzw. das Programm beenden kann.
Für alle Funktionen (ohne main) sind Entwurf und Testplan zu erstellen.

Code:

#include <iostream>
using namespace std;

void inputValue(int a, int b)
{
}

void inputValue(int *pa, int *pb)
{

}

void outputValue(int a, int b)
{

}

void outputValue(int *pa, int *pb)
{
}

void swap(int *pa, int *pb)
{
	int tmp;
	tmp=*pa;
	*pa=*pb;
	*pb=tmp;
}

int main()
{
	int a,b;
	int auswahl;
	bool wiederholung=true;

	do
	{

		cout<<"Welchen Befehl wollen sie durchfuehren"<<endl<<endl;
		cout<<"Zahlen eingeben (1)"<<endl;
		cout<<"Referenz ausgeben (2)"<<endl;
		cout<<"Swap-Funktion (3)"<<endl;
		cout<<"Programm beenden (4)"<<endl;
		cin>>auswahl;

		system("cls");

		switch (auswahl)
		{
		case 1:
		{

			cout<<"Geben Sie Ihre Zahlen an :"<<endl;

			cin>>a;

			cin>>b;
		}

		break;

		case 2:
		{
			cout<<"  A ist = "<<&a<<endl;
			cout<<"  B ist = "<<&b<<endl;
		}
		break;

		case 3:
		{

			inputValue(a,b);
			swap(a,b);
			outputValue(a,b);

			cout<<"  A ist = "<<a<<endl;
			cout<<"  B ist = "<<b<<endl;
		}
		break;

		case 4:
			wiederholung=false;
			break;
		}

	} while (wiederholung ==true);

	return 0;
}

das sind quasi andere namen für ein-und-dieselbe variable. deklariert wird das mit dem kaufmännischen und zeichen

beispiel:

int a = 5;
int & refA = a; // a und refA 'zeigen' auf den gleichen speicherplatz, sprich sind gleich

cout << a << endl; // "5"
cout << refA << endl; // "5"
// hier sind a und damit auch refA gleich 5
a = 6;
cout << a << endl; // "6"
cout << refA << endl; // "6"
refA = 7;
cout << a << endl; // "7"
cout << refA << endl; // "7"

soweit verstanden?

also wie zeiger, nur der umweg über die dereferenzierung(*ptA = 5;) fällt weg.

und das sollst du jetzt in die funktionen einbauen:

void inputValue(int & a, int & b) // referenzen als parameter
{
    cin >> a >> b;
}

void inputValue(int * pa, int * pb) // zeigerals parameter
{
    cin >> *pa >> *pb;
}

void outputValue(int const& a, int const& b)
{
    cout << a << ", " << b << endl;
}

void outputValue(int const *const pa, int const * const pb)
{
    cout << pa << ", " << pb << endl;
}

int main()
{
    int a = 5;
    int b = 6;
    // ...

    inputValue(a, b); // referenz !!
    // ...
    inputValue(&a, &b); // per zeiger !

    // ...
}

void outputValue(int const *const pa, int const * const pb)
{
    cout << pa << ", " << pb << endl;
}

Ist alles korrekt, aber macht es auch Sinn? Das jeweils erste const bezieht sich auf den Wert, auf den der Pointer zeigt. Es macht Sinn diesen als const zu deklarieren. Der Aufrufer weiss dann, dass die Funktion den Wert nicht verändert.

Das jeweils 2te const bezieht sich auf den Pointer selbst. Welchen Sinn macht es diesen als const zu deklarieren?

Gibt es eigentlich einen Unterschied zwischen den folgenden Funktionen?

void outputValue(const int *pa)
{
    cout << pa << endl;
}

void outputValue(int const *pa)
{
    cout << pa << endl;
}

Ich nehme immer die erste Variante und sie tut was man erwartet...

Der Post von Seldon:

char const *params ist das selbe wie const char *params - eine Zeigervariable auf char-Konstante.
const char const *params ist ein Fehler; zweimal const auf char geht nicht.
char *const params ist eine Zeigerkonstante auf char-Variable.

char const *const params ist eine Zeigerkonstante auf char-Konstante.
char const *const *const params ...und so weiter halt.

Ob es in dem Zusammenhang das gleiche ist, weiß ich nicht genau, denke aber schon..?!

http://devmaster.net/forums/topic/2888-difference-between-const-int-i-and-int-const-i/

IDENTIFIER///Bezeichner von..
const  ///Konstantem
*      ///Zeiger (auf)
const  ///Konstantes
char   ///Objekt

char const * const IDENTIFIER;

aber es geht hier ja nicht um const sondern eigentlich um die aufgabe. dazu hat sich der TE ja noch überhaupt nicht mehr geäussert

das const kann man machen, muss man nicht und dass ichs was übertrieben hab war zu meinem persönlichen spass

Auch an alle anderen Danke, die mir helfen wollten