Dyn. Pointer benutzen?



  • Hi,

    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 )



  • C++ unterscheidet Groß-/Kleinschreibung.
    Nein, dun kannst ausserhalb nicht darauf zugreifen.



    1. pzahl und pZahl sind zwei unterschiedliche identifier.
    2. manuelle speicherverwaltung ist sinnlos und fehleranfällig.
    3. du erzeugst hier ein speicherleck, nur weil du 2) missachtet hast...


  • Ahhhh, doofer Schreibfehler, danke.^^

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

    Ist halt eine Schulaufgabe die wir lösen sollen.



  • Du brauchst höchstwahrscheinlich keine dynamische Speicherverwaltung.
    Damit deine Eingabe-Funktion aber etwas einlesen kann, musst du ihr die Variable (per Referenz/Pointer) übergeben, wo sie hinein lesen soll.



  • Kalicronic schrieb:

    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.



  • Wir hatten eine Beispielaufgabe auf dem PC in der Schule, aber keine infos im Hefter dazu. -.-"

    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);
    


  • Hallo,

    einfach

    int zahl;
    Eingabe(zahl);
    

    Und die Funktion dann so definieren:

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

    (also den Parameter mittels Referenz übergeben).



  • 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;
    }
    

  • Mod

    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 😃 .



  • SeppJ schrieb:

    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.



  • Das es mit einer normalen Deklaration funktioniert das weis ich. trotzdem danke ^^

    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
    	}
    }
    


  • volkard schrieb:

    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;
    }
    

Log in to reply