Funktionen und Zeiger

reparier bitte (wiedermal) alle variablennamen, damit man weiss was du meinst

nein, in der 2. funktion brauchst du kein malloc mehr.
hast du einmal den speicher mit malloc reserviert beleibt dieser so lange erhalten bis mit free wieder freigegeben wird, oder bis das programm beendet wird.

in deinem beispiel hättest du ein speicher-leck:

rückgabewert2 = malloc(sizeof(int);
... hier reservierst du zum ersten mal speicher, und "rückgabewert2" beinhaltet den zeiger auf diesen speicher.

rückgabewert2 = (int*) funktion1();
... hier reserviert "funktion1()" zum 2. mal speicher, "rückgabewert2" wird mit dem zeiger auf den 2. speicher überschrieben. der zuerst reservierte speicher ist immer noch vorhanden, nur der zeiger mit dem du darauf zugreifen könntest ist weg.

ich versteh echt nicht, wieso so viele leute probleme haben mit pointern...

Stell dir vor, du hast einen Block Speicher. Der ist durchnummeriert von 0 bis 0xFFFF. Wenn du malloc aufrufst, sucht es der in der Speicherzuordnungsliste nach einem durchgehenden Teil mit der als malloc-Parameter angegebenen Größe in diesem Speicher, der noch *nicht* in der Liste steht. Dann trägt malloc die Startadresse und Länge in die Liste ein, und returnt die Startadresse (das ist nix anderes als eine Zahl zwischen 0 und 0xFFFF!).
Dieser Speicherbereich ist jetzt dein, du kannst darin machen was du willst. Wenn du free() aufrufst, sucht diese Funktion einen Eintrag mit der von dir angegebenen Startadresse (wieder Hinweis: das ist eine Zahl zwischen 0 und 0xFFFF).
Wenn du jetzt malloc aufrufst, und diese Zahl lokal speicherst, kannst du eben auf deinen Speicherbereich zugreifen (weil du ja die Adresse kennst). Wenn du jetzt den Wert überspeicherst, weißt du nicht mehr, wo dein anderer Block war (nennt sich dann Leak).

ja so ist es.

stell dir einen pointer als int-wert vor in dem einfach die startadresse des reservierten speichers drinnen steht. übergibst du einer funktion einen pointer (bzw. gibt eine funktion einen pointer zurück) wird für diesen pointer ein "call by value" gemacht, d.h. die adresse die im pointer steht wird einfach in eine neue variable kopiert, welche automatisch wieder zerstört wird wenn die funktion (bzw. der block) verlassen wird.

Wie bereits von mir gesagt, ein pointer ist nur eine ZAHL und kann auch als solche behandelt werden (in C/C++ sogar mit addition, etc).

Im Übrigen würde ich diese Praxis (in funktion1() allozieren, vom Aufrufer freigeben) nicht unbedingt vorziehen. (Und das einmal ganz abgesehen davon, dass das Ersetzen von int durch int* nichts bringt, sondern eher nur für größere Objekte.)

Also, rein vom guten Geschmack und der Durchsichtigkeit des Codes wegen würde ich solche Konstrukte vorziehen, die das Allozieren und Deallozieren auf der gleichen Ebene bewerkstelligen. Die Funktion selber würde dann einfach annehmen, dass der int-Pointer schon alloziert wurde, und im Idealfall brauchst du malloc() und free() gar nicht:

void irgendeinefunktion() {
    int rückgabewert;
    funktion1( &rückgabewert1 );
}


bool funktion1( int* ergebnis ) {
    *ergebnis = irgendeine + rechnung;
    if( erfolgreich )
        return true;
    else
        return false;
}

Damit ersparst du dir potenizelle Memory-Leaks, die durch Vergessen von free() vorkommen würden, und hast außerdem eine Möglichkeit, eine "hat funktioniert oder nicht" Returnvariable zurückzugeben. Natürlich gibts trotzdem Fälle, in denen die Funktion selber allozieren sollte (z.B. das Abstract Factory design pattern), aber im Allgemeinen ist das ohne Garbage Collection wie in Java nicht unbedingt so eine tolle Idee.