julsos

PS. Im Grunde hast du natürlich recht und ich bin ja auch schon dran mir das selbst beizubringen, aber manchmal braucht man vielleicht doch noch Hilfe zu individuellen Sachen. Ein Buch oder ein spezialisiertes YouTubeVideo liefert einfach nicht immer die Hilfe die ein Mensch einem direkt geben kann

Sinnvolle Frage.
Ich würde sagen: Pauk erstmal die Grundlagen, bevor du jetzt täglich ein neues Thema zu einer Aufgabe eröffnest.

Die Problematik ist wohl, dass du nicht verstehst, wie Funktionen funktionieren.
Falls in eine Funktion Parameter übergeben werden müssen, dann werden immer Kopien der Parameter übergeben. Das wird "call-by-value" genannt. Das ist in sofern nützlich, dass die Variablen im inneren der Funktion eine anderen Gültigkeitsbereich haben und sie außerhalb der Funktion unberührt bleiben. 
Es gibt aber manchmal Situationen, da möchte man den Wert einer Variable, der außerhalb der Funktion gilt, ändern. Dann muss man die Variable als Referenz in die Funktion überreichen. Das nennt sich dann "call-by-reference" und hier kommen wir nun zu deinen Fragen:
Das & ist der sog. Adress-Operator. Es wird also direkt die Adresse von s1 übergeben. Also a ist die Adresse von s1.
Angenommen die Adresse von s1 ist 0x00000001, dann ist a ebenfalls 0x00000001. Das ist das besagte call-by-reference. Wir können direkt mit dem Objekt arbeiten.
Dies ist wiederum ein Zeiger. Ein Zeiger ist ja eine Variable, die als Wert eine Adresse besitzt. Im Funktionsaufruf f(s1, &s2); überreichen wir der Funktion die Adresse von s2 (wegen dem Adress-Operator). Da es sich hier um Call-by-Value handelt, wird die Adresse kopiert und in einen anderen Speicherbereich abgelegt. Das ist unser Zeiger. Der Zeiger hat dann die Adresse 0x00000002 und als Wert 0x00000001.
Der Pfeil ist ebenfalls ein Zugriffs-Operator, wie der Punkt, allerdings für Zeiger.
Anstatt dem Pfeil könntest du auch die Dereferenzierung verwenden. Also (*b).x = 2;

Bist du sicher? Wie kannst du das Ergebnis verstehen, wenn du die Operatoren gar nicht kennst?
1. Das ist der Adressoperator, liefert zu einer Variable die Adresse.
2. Das ist der Dereferenzierungsoperator, der liefert dir den Inhalt einer Zeigervariablen.
3. Das ist einer der Elementzugriffsoperatoren. Das ist eine Kurzschreibweise für (*variable).element. Der macht also im Grunde das Gleiche wie der . nur dass dieser Operator direkt auf Zeigervariablen funktioniert.
 
Achso sorry, du meintest speziell bei Funktionen. Da sagt dir das & und * eben, dass es Referenz bzw. ein Zeiger ist.

Welche Stellen sind denn zurzeit noch unklar? Wie würdest du Strukturen definieren und wann denkst du, lohnt es sich diese zu verwenden? Sind eigentlich alle Beispiele/Aufgaben in deinem Kurs/Buch(?) in dieser nicht aussagekräftigen Art geschrieben? Ich glaube, mit sinnvollen Beispielen für Strukturen wäre das auch direkt viel klarer. z. B. sowas:
Ich glaube, dass eigentliche Hauptaugenmerk bei der Aufgabe ist die Funktion f die einmal einen direkten Wert als Parameter verlangt und einmal eine Referenz. Ich nenne mal hier die beiden Begriffe Pass by Value und Pass by Reference, wenn du die beiden Konzepte verinnerlicht hast, erklärt sich auch warum der Output bei der Aufgabe 1 und 2 ist und nicht 7 und 2.

Das ist wirklich schade das hier so wenig Arbeit in die Aufgaben gesteckt wird, besonders wenn es um Grundlagen geht. Aussagekräftige Variablen-/ und Funktionsbezeichnungen in einfachen und sinnvollen Beispielen würden das nachvollziehen um einiges einfach machen. Aber gut da es kein Buch, sondern ein Kurs ist, kann man da nicht viel machen.
In C hast du die Möglichkeit, einen Parameter über zwei unterschiedliche Wege zu übergeben. Hierbei ist es auch unabhängig, ob der Parameter ein einfacher Datentyp ist oder eine Struktur oder etwas anderes ist. Pass By Value ist wohl der gängigste Typ
Angenommen ich habe jetzt zwei Variablen zahl1, zahl2, vom Typen int die ich nun übergebe:
Beim Aufruf dieser Methode wird jetzt eine Kopie von zahl1 und zahl2 erstellt, es werden also im Speicher zwei weitere Variablen angelegt, die auch zusätzlichen Speicherplatz benötigen. Die beiden Variablen "firstNumber" und "secondNumber" kann ich jetzt frei innerhalb meiner add Methode überschreiben, ohne das die "originalen" Variablen zahl1 und zahl2 verändert werden.
Der andere Weg ist Pass By Reference hier wird einfach nur ein Verweis an die add Methode übergeben. firstNumber und secondNumber zeigen jetzt also auf die gleiche Adresse wie die von zahl1 und zahl2. Wenn ich jetzt in firstNumber einen anderen Wert zuweise, wird auch gleichzeitig zahl1 verändert.

Vielleicht muss man da ein bisschen weiter ausholen. Zeiger sind Variablen, die als Wert die Speicheradresse einer anderen Variable enthalten. Ein Array hingegen ist die Speicheradresse auf das erste Element des Arrays. Ein Array wird als ganzer Block im Speicher allokiert.
feld1 und feld2 sind nun Arrays. Also eine Adresse. Das kannst du auch sehen, wenn du 
cout << feld1; ausführst. Dann wird eine Adresse ausgegeben. Um die Adresse des nächsten Elementes auszuweisen, kannst du 
cout << feld1 + 1; schreiben. Du wirst feststellen, dass die Adresse um 4 Bytes (bzw. 8 Bytes; je nach Compiler) höher ist, als die Adresse von feld1. Das liegt eben daran, dass ein Array, wie schon erwähnt, als ganzen Block im Speicher liegt. Da wird angeben müssen, welchen Datentyp das Array speichert, weiß das Programm nun, ab welcher Adresse das nächste Element anfängt. In unserem Fall 4/8 Bytes, da ein Integer 4/8 Bytes groß ist.
In der Zeile 8 wird jetzt nun ein Array von int-Zeigern (also Adressen) erzeugt und besitzt zwei Elemente (int* ipf[2]), nämlich die Adressen von feld1 und feld2.
In Zeile 9 wird die Adresse von feld1 gespeichert.
In Zeile 10 wird zunächst der zweite Wert aus dem Array genommen. Das entspricht der Adresse von feld2 und holen uns dann mit dem Stern den Wert aus dieser Adresse: 29. Dann wird der Wert noch mit 1 addiert und ausgewiesen wird dann die 30.
In Zeile 11 wird der erste Wert aus dem Array genommen. Also die Adresse von feld1 und mit dem Wert von der Variable ip substrahiert. Der Wert von ip ist ebenfalls die Adresse von feld1. Aber Achtung: Es wird nicht 13 - 13 gerechnet, sondern Adresse - Adresse. Das kannst du nämlich sehen, wenn du die Zeilen
cout << ipf[0] << endl; cout << ip << endl; ausführst.

Am einfachsten lassen sich solche Code Ausschnitte in kleinen Konsolenanwendungen testen in denen man einen Haltepunkt setzt und dann Zeile für Zeile die Variablen prüft wie diese sich Verändern.
In Zeile 6 und 7 werden die beiden Arrays vom Typ Integer erstellt und mit den entsprechenden Werten initialisiert.
In Zeile 8 wird nun ein Zeiger auf ein Array mit der Größe 2 vom Typen Integer definiert und mit den beiden Adressen von feld1 und feld2 initalisiert. ipf[] beinhaltet nun also 2 Adressen und diese sind die von feld1 und feld2. Die Adressen von einem Array zeigen immer auf das erste Element im Array also z. B:
Zeile 9 ist ein weiterer Zeiger auf eine Integer Variable die, die gleiche Adresse erhält wie feld1 also:
Zeile 10 dereferenziert ipf[1] und addiert dann noch den Wert 1 dazu. ipf[1] entspricht der Adresse des Arrays feld2 bzw. dessen ersten Element also 29. Und 29 + 1 sind eben 30, was die Ausgabe auch nochmal bestätigt.
In der letzten interessanten Zeile wird die Adresse ipf[0], welche dem ersten Element von feld1 entspricht also 13, subtrahiert mit der Adresse auf die ip zeigt, welche sich aus Zeile 9 ergibt, es zeigen also beide auf die gleiche Adresse, also 13 - 13 = 0.
Was mich an der Aufgabe etwas überrascht hat war, das man in der Zeile 11:
keine Sterne angeben musste um die Adresse wieder zu dereferenzieren, also eigentlich hätte ich es so erwartet, was zum gleichen Output führt:
möglicherweise wird die Ausgabe wohl direkt als Wert ausgegeben wenn man mit zwei Adressen Rechenoperationen durchführt, hier bin ich mir aber nicht sicher.