Bei f() da bekommt halt der Pointer eine Adresse und bei f2() dann bekommt die Referenz eine Adresse läuft das ganze daher nicht auf das selbe hinaus oder vertu ich mich da jetzt?

#include <iostream>
using namespace std;

int f (   long *abc)
{
        cout<< "f a1: " << &abc <<endl; // Adresse wo der Pointer steht: 1245060
        cout<< "f v1: " << *abc << endl;  //Die Adresse v aus "int main()" 1245064
}

int f2 (   long &abc)
{
        cout<< "f2 a1: " << &abc <<endl;   //Die Adresse v aus "int main()" 1245064
        cout<<  "f2 v1: " <<abc << endl;   //Die Adresse v aus "int main()" 1245064
}

int main(int argc, char* argv[])
{

long v = 123;

        cout<<"m a: " << &v<<endl;

        f ( &v );
        f2(v);

system("PAUSE");
}

Hallo, sind hier beide Funktionen ( f() und f2() ) gleich performant?

Gleich performant, ja. Aber sie tun nicht wirklich das gleiche.

Dein Code etwas modifiziert (Funktionsparameter umbenannt):

int f(long *ptr)
{
  cout<< "f a1: " << &ptr << endl;  // Adresse wo der Pointer steht
  cout<< "f v1: " << *ptr << endl;  // Die Adresse v aus "int main()"
}

int f2 (long &ref)
{
  cout<< "f2 a1: " << &ref << endl;  // Die Adresse v aus "int main()"
  cout<< "f2 v1: " <<  ref << endl;  // Die Adresse v aus "int main()"
}

int main(int argc, char* argv[])
{
  long v = 123;
  f (&v);
  f2( v);
}

Die Kommentare sind teils falsch.
Die Addresse von v ist ptr, nicht *ptr. *ptr liefert Dir das Objekt v selbst.
Und der Ausdruck ref liefert dir auch das Objekt v und nicht seine Adresse.

cout<< "f v1: " << *ptr << endl;  // Pointer der auf die Adresse v aus "int main()" zeigt

cout<< "f v1: " << *ptr << endl;  // Wert der Variablen aus main() auf die ptr zeigt ausgeben

Also müsste ich hier sagen? [...]

Nein. Was willst Du denn da ausgeben? Die Adresse? Die Adresse ist in ptr gespeichert, ptr ist die Zeigervariable. Zeigarvariablen sind dazu da, Adressen zu speichern.

void f1(int* ptr)
{
  cout << "Die Adresse des int-Objekts ist " << ptr << endl;
  cout << "Der int-Wert, der dort gespeichert wird, ist " << *ptr << endl;
}

void f2(int& ref)
{
  cout << "Die Adresse des int-Objekts ist " << &ref << endl;
  cout << "Der int-Wert, der dort gespeichert wird, ist " << ref << endl;
}

Auf Maschinenebene sollte es keinen Unterschied zwischen diesen beiden Funktionen geben.

Achte darauf, dass hier & und * jeweils einmal als Deklarator verwendet wird und einmal als Operator. Das darf man nicht durcheinander bringen.
& als Deklarator deklariert eine Referenz.
& als Operator ist der Adressoperator.
* als Deklarator deklariert einen Zeiger.
* als Operator dereferenziert eine Adresse.

Eine Referenz ist quasi ein sich selbst dereferenzierender, konstanter Zeiger. So habe ich mir das immer vorgestellt. Andere ziehen es vor, von "Aliasen" zu reden à la "Eine Referenz ist nur ein anderer Name desselben Objekts".

Gleich performant, ja.

Nein, ungleich.
&ptr und &ref sind nicht gleich schnell.