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

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.

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é

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

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.

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.

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é

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.