Zeiger an Funktion

Hallo ich will der var Variable mit einem Zeiger einen neuen Wert zuweisen:

Aber ich bekomme immer diese Fehler

Erzeugen
[C++ Fehler] Unit1.cpp(36): E2034 Konvertierung von 'int' nach 'int *' nicht möglich
[C++ Fehler] Unit1.cpp(36): E2342 Keine Übereinstimmung des Typs beim Parameter 'z1' ('int *' erwartet, 'int' erhalten)
[C++ Warnung] Unit1.cpp(50): W8070 Funktion sollte einen Wert zurückgeben

#include <iostream>

using namespace std;

int main()
{
int zahl (int *z1 );

zahl(4);

system("PAUSE");
}

        int zahl ( int *z1)
        {
        int var = 2;
        cout<<"alter wert: "<<var<<endl;

        var = *z1;

        cout<<"neuer wert: "<<var;
        }

Firefighter

Auweia...du solltest dir mal ein gutes Buch zur Hand nehmen.

1.Es ist eher ungewöhnlich eine Funktion lokal in der Main zu deklarieren, ich bin mir nichtmal sicher ob das überhaupt funktioniert.
2.Du kannst einer Funktion die einen Zeiger nimmt, keinen konstanten Wert übergeben wie du es gemacht hast, und besonders noch weniger einen Integer übergeben, wenn ein Zeiger auf int erwartet wird.
3.Die Funktion solltest du auch nochmal überarbeiten, wie gesagt nimm dir ein Tutorial zur Hand.

It0101

4. Codeblöcke einrücken, um dem Leser das Verständnis zu erleichtern.

asc

func schrieb:

Hallo ich will der var Variable mit einem Zeiger einen neuen Wert zuweisen:

Mit Referenzen und Sprechenden Namen (zumindestens für den Leser) geht es einfacher... Zudem ist die Frage warum du der Funktion einen Rückgabewert gibst, aber nichts zurücklieferst.

Ich gehe hier mal 2 Varianten durch

#include <iostream>

using namespace std;

// Ohne Rückgabewert, mit Referenzübergabe
void zahlVerdoppelnReferenz(int & zahl);
// Mit Rückgabewert, und Wertübergabe
int zahlVerdoppelnWert(int zahl);

int main()
{
    int zahl = 4;
    zahlVerdoppelnReferenz(zahl);    // Verdopplung über Referenz
    zahl = zahlVerdoppelnWert(zahl); // Verdopplung über Rückgabewert

    system("PAUSE");
}

void zahlVerdoppelnReferenz(int & zahl)
{
    zahl *= 2; // Hier wird die Übergabe direkt geändert
}

int zahlVerdoppelnWert(int zahl)
{
    return zahl * 2; // Hier wird die Übergabe nicht geändert, und der Berechnete
    // Wert zurückgegeben
}

Die zweite Variante ist häufig die Üblichere.

cu André

Eine Frag hab ich noch man kann das ja einmal so machen:

void zahlVerdoppelnReferenz(int &zahl);

oder so

void zahlVerdoppelnReferenz(int zahl);

also ohne diese Zeichen & wo ist da der unterschied ob ich das jetzt mit oder ohne mache?

Weil beides funktioniert.

#include <iostream>

using namespace std; 

void zahlVerdoppelnReferenz(int  &zahl);

int main()
{ 
int zahl;

        cout<<"Eingabe: ";
        cin>>zahl;

        zahlVerdoppelnReferenz(zahl);

system("PAUSE");
}

        void zahlVerdoppelnReferenz(int &zahl)
        {
        int erg = 1;

                cout<<"Erg alt: "<<erg<<endl;

                    erg = zahl;

                cout<<"Erg neu: "<<erg<<endl;
        }

_matze

Das eine ist eine Übergabe by-reference (du veränderst direkt die ursprüngliche Variable), das andere ist Übergabe by-value (du legst eine Kopie der ursprünglichen Variable an, die lokal in der Funktion existiert; Änderungen wirken sich eben nicht auf die übergebene Variable aus).

Firefighter

Edit:Hrrr zu spät...

Was ist denn besser by-reference oder by-value oder ist das egal was man nimmt ?

_matze

func schrieb:

Was ist denn besser by-reference oder by-value oder ist das egal was man nimmt ?

Wie besser?? Das hängt davon ab, was du machen willst! Das musst du bei jedem Fall selbst entscheiden. Zieh dir doch besser mal ein gutes Buch/Tutorial 'rein und lerne Programmieren von Grund auf. Mit solchen ungezielten Fragen kommst du nicht weit.

Hab was gefunden :>

Aber im moment bin ich an einem anderen Tutorial dran etweder hab ichs mal wieder vergessen oder überlesen aber naja jetzt weiss ich ja wofür die reference gut ist.

Danke für alle antworten von euch.

http://tutorial.schornboeck.net/referenzen.htm

Der Sinn von konstanten Referenzen bei Funktionsaufrufen (im Vergleich zu "call by value")? Ganz einfach: bei einer Referenz wir keine Kopie der originalen Variablen erstellt. Das hat vorallem dann Sinn, wenn wir mit Variablen hantieren, die viele Daten beinhalten.

asc

func schrieb:

Hab was gefunden :>

Ich rate dir wirklich zu einem Buch. Ich kenne kein Tutorial was wirklich gut und auch umfangreich genug ist. Und bei den Büchern auch etwas aufpassen (Aktuell und richtig sind leider nur ein kleiner Teil, selbst bei "neuen" Büchern. Weitgehend aktuell sind z.B. "C++ Primer" und "Thinking in C++" [letzteres gibt es legal kostenlos im Internet; englisch]).

cu André

Nexus

Firefighter schrieb:

1.Es ist eher ungewöhnlich eine Funktion lokal in der Main zu deklarieren, ich bin mir nichtmal sicher ob das überhaupt funktioniert.

Doch, Funktionsdeklarationen sind innerhalb von Funktionen erlaubt. Nur Definitionen nicht.

func schrieb:

Der Sinn von konstanten Referenzen bei Funktionsaufrufen (im Vergleich zu "call by value")? Ganz einfach: bei einer Referenz wir keine Kopie der originalen Variablen erstellt. Das hat vorallem dann Sinn, wenn wir mit Variablen hantieren, die viele Daten beinhalten.

Referenzen sind immer konstant. Das const bei einer Const-Referenz bezieht sich auf das verwiesene Objekt.

Eingebaute Typen würde ich im Allgemeinen als Kopie übergeben, da eine Referenz im Vergleich zum Objekt relativ viel Speicher beansprucht und die Dereferenzierung auch Zeit braucht. Je grösser das Objekt (v.a. Klassentypen), desto eher lohnt sich eine Const-Referenz. Wenn das Objekt verändert werden soll, sind normale Referenzen eine Möglichkeit.

Ansonsten gibt es auch noch Zeiger, die ein wenig flexibler sind und Null als Wert annehmen können.

Firefighter

@Nexus Ah ok alles klar, ich wusste doch eins von beiden geht nicht. Sagte ja nicht umsonst "eher" ungewöhnlich Aber ok, es funktioniert.