Hier mein Problem:

void Eingabe()
{
	int *pzahl = new int;
	cin >> *pZahl; 
}

Er sagt mit bei der "cin >> *pZahl;" das sie nicht deklariert ist.
Ich denke ich hab da etwas noch nicht ganz verstanden denke ich mal, aber weis nicht genau was.^^

Kann ich jetzt außerhalb dieser Funktion auch auf diesen Pointer zugreifen, wenn er denn Funktioniert.
Also ich weis das Pointer ja Global funktionieren,
wenn man das so sagen kann, aber woher weis ich denn
eigentlich wie dieser Pointer heißen sollte,
wenn ich diese Funktion nicht geschrieben hätte?

(oder hab ich gerade nen mega denkbug?! Oo )

Also muss ich die Dyn. Speicherverwaltung immer über die main Funktion machen?

Ist halt eine Schulaufgabe die wir lösen sollen.

Also muss ich die Dyn. Speicherverwaltung immer über die main Funktion machen?

Selbstverständlich nicht!

Kalicronic schrieb:

Ist halt eine Schulaufgabe die wir lösen sollen.

Dann musst du halt mal in dein Lehrbuch schauen. Wie die Speicherverwaltung geht, wird man dir ja wohl vorher beigebracht haben.

Also ich hab es jetzt in der main Funktion gemacht, aber sobald ich es mit "&" in die Funktion übergeben will sagt er: "Error: Das Argument vom Typ ""int**"" ist mit dem Parameter vom Typ Typ ""int*"" inkompatibel."

Also ich hab mir auch noch mal tutorials angeschaut und in einem Buch, aber irwas versteh ich da nicht so.

int *pZahl = new int;
Eingabe (&pZahl);

einfach

int zahl;
Eingabe(zahl);

Und die Funktion dann so definieren:

void Eingabe(int & zahl)
{
    cin >> zahl;
}

(also den Parameter mittels Referenz übergeben).

void Eingabe(int & zahl)
{
    cin >> zahl;
}
int main()
{
    int x;
    Eingabe(x);
    cout<<x;
}

Wobei es aber gar keinen Grund gibt, Zeiger zu vermeiden. Zeiger haben erstmal nix mit "gefährlicher" manueller Speicherverwelatung zu tun.

void Eingabe(int * zahl)
{
    cin >> *zahl;
}
int main()
{
    int x;
    Eingabe(&x);
    cout<<x;
}

Wobei es aber gar keinen Grund gibt, Zeiger zu vermeiden. Zeiger haben erstmal nix mit "gefährlicher" manueller Speicherverwelatung zu tun.

Wunderschön, wie du die andere "Gefahr" in deinem Beispiel demonstrierst, nämlich die unnötig umständliche Syntax, indem du es prompt falsch machst .

volkard schrieb:

Wobei es aber gar keinen Grund gibt, Zeiger zu vermeiden. Zeiger haben erstmal nix mit "gefährlicher" manueller Speicherverwelatung zu tun.

Wunderschön, wie du die andere "Gefahr" in deinem Beispiel demonstrierst, nämlich die unnötig umständliche Syntax, indem du es prompt falsch machst .

Ach, Copy&Paste in diesem Textfeld des Forums…, hätte die Zeigerversion erst vorgelegen, wäre der Fehler in die Referenzfunktion passiert.

Ich muss aber eine Dynamische Speicherverwaltung nutzen mit Pointer halt,
also: "int *pZahl=new int;"

nur sobald ich sie in eine Funktion mit "&" rein gebe meldet er den Fehler wie oben erwähnt.

Meine Aufgabe: Schreiben sie eine Funktion, welche die Teilbarkeit einer eingegebenen Zahl durch 2 untersucht.
-Übergeben Sie die Parameter an die Funktion als Referenz
-Verwenden Sie die dynamische Speicherverwaltung
-Testen Sie die Funktion in einem Programm Zwei:Teilbarkeit

Hier das was ich bis jetzt geschrieben habe:

#include "stdafx.h"
#include <iostream>
#include "teilen.h"
#include <locale>
using namespace std;

void Eingabe(int *pZahl)//Liest eine integer eingabe eines User ein und gibt diesen zurück
void Verarbeitung(int *pZahl, bool *pgerade_ungerade)//Prüft Zahl auf teilbarkeit und gibt bool wert zurück
void Verarbeitung(int *pZahl, bool *pgerade_ungerade)//gibt Zahl und teilbarkeit aus

int _tmain(int argc, _TCHAR* argv[])
{
	std::locale::global(std::locale("German"));		//Deutschsprachige Sonderzeichen werden erkannt und korrekt ausgegeben

	while (1)										//endloss Schleife die das Programm immer wieder neustartet
	{
		system("Cls");								//löscht Bildschirmausgabe

		int *pZahl = new int;
		Eingabe(&pZahl);							//Springe in Funktion Eingabe, übergebe pZahl

		bool *pgerade_ungerade = new bool;
		Verarbeitung(&pZahl, &pgerade_ungerade);	//Springe in Funktion Verarbeitung, übergebe pZahl und pgerade_ungerade

		Ausgabe(&pZahl, &pgerade_ungerade);			//Springe in Funktion Ausgabe, übergebe pZahl und pgerade_ungerade

		system("pause");							//Programm Pausieren
	}

	return 0;										//Rückgabewert 0 (Programm ende)
}

void Eingabe(int *pZahl)			//Liest eine integer eingabe eines User ein und gibt diesen zurück
{
	cout << "\n\n\tInfo: Programm läuft in einer Endlosschleife!";		//Eingabe: Info an User
	cout << "\n\n\tZahl eingeben: ";									//Eingabe: User soll Zahl eingeben
	cin >> *pZahl;														//Eingabe: Speicher User eingabe
}

void Verarbeitung(int *pZahl, bool *pgerade_ungerade)//Prüft Zahl auf teilbarkeit und gibt bool wert zurück
{
	if ((*pZahl % 2) == 0)	//Wenn rest gleich 0
	{
		*pgerade_ungerade = 1;	//dann gerade teilbare zahl, speicher 1 als bool wert
	}
	else
	{
		*pgerade_ungerade = 0;	//sonst ungerade  nicht teilbare zahl, speicher 0 als bool wert
	}
}

void Ausgabe(int *pZahl, bool *pgerade_ungerade)//gibt Zahl und teilbarkeit aus
{
	if (*pgerade_ungerade = 1)	//wenn bool wert 1
	{
		cout << "\n\t" << *pZahl << ", ist eine Gerade zahl die durch 2 Teilbar ist." << "\n\n\n\n\n\t"; //Dann: Bildschirmausgabe: Zahl gerade und teilbarkeit anzeigen
	}
	else
	{
		cout << "\n\t" << *pZahl << ", ist eine Ungerade zahl die durch 2 nicht Teilbar ist." << "\n\n\n\n\n\t";	//Sonst: Bildschirmausgabe: Zahl ungerade und nichtteilbarkeit anzeigen
	}
}

Also

void Eingabe(int & zahl)
{
    cin >> zahl;
}
int main()
{
    int x;
    Eingabe(x);
    cout<<x;
}

Wobei es aber gar keinen Grund gibt, Zeiger zu vermeiden. Zeiger haben erstmal nix mit "gefährlicher" manueller Speicherverwelatung zu tun.

void Eingabe(int * zahl)
{
    cin >> *zahl;
}
int main()
{
    int x;
    Eingabe(&x);
    cout<<x;
}

Ich muss aber eine Dynamische Speicherverwaltung nutzen mit Pointer halt,
also: "int *pZahl=new int;"

nur sobald ich sie in eine Funktion mit "&" rein gebe meldet er den Fehler wie oben erwähnt.

void Eingabe(int & zahl)
{
    cin >> zahl;
}
int main()
{
    int *x=new int;
    Eingabe(*x);
    cout<<x;
    delete x;
}
[cpp]
void Eingabe(int * zahl)
{
    cin >> *zahl;
}
int main()
{
    int *x=new int;
    Eingabe(x);//x ist ja schon ein Zeiger, passt schon
    cout<<x;
    delete x;
}