habe hier schon öfters gelesen, daß es einen Unterschied macht, ob man eine Referenz oder einen Pointer übergibt.

Daraufhin habe ich mal ein kleines Testprogramm geschrieben und nach dem Kompilieren disassembliert, allerdings kommt exakt der gleiche Code dabei raus.

Kann das nun an einer Compiler-Optimierung liegen? Oder äußert sich der Unterschied womöglich nur in der Programmierung und nicht im fertig kompilierten Programm? Oder wäre es vielleicht anders kompiliert worden, wenn in der aufgerufenen Funktion noch mehr passieren würde?

Hier ist der Code (in der Pointer-Version):

#include <stdio.h>

class Test
{
public:
    Test(int _a, int _b) : a(_a), b(_b)
    {

    }

    int getA()
    {
        return a;
    }

    int getB()
    {
        return b;
    }

private:
    int a;
    int b;
};

int sum(Test* test)
{
    printf("Jetzt wird die Summe berechnet\n");
    return test->getA() + test->getB();
}

int main()
{
    printf("Hier geht's los!\n");
    Test test = Test(50, 30);

    int s = sum(&test);
    printf("%i\n", s);

    return 0;
}

Übrigens, ich habe auch mal versucht, eine const-Referenz zu übergeben, aber das wollte er mir nicht kompilieren... Wie müßte ich denn das Objekt dazu übergeben?

@const: ein 'const Test&' ist eine Referenz auf ein konstantes Objekt - bei dem kannst du die Methoden getA() und getB() nicht verwenden, weil sie nicht als const gekennzeichnet sind.

class Test
{
public:
    ...    
    int getA() /*hier:*/ const
    {
        return a;
    }
    ...
};

Edit: @TLEP: Aus C++ Sicht sind Referenzen "nur" ein Alias für eine andere Variable. Aber der Compiler muß das auch auf eine Art darstellen, die dein Rechner versteht - und wenn der keine eingebauten Referenzen hat, werden dafür hinter den Kulissen wieder Zeiger verwendet.

Das andere noch nicht ganz - okay, daß Pointer Variablen sind und Referenzen die Adressen ist mir eigentlich klar, aber in welchen Fällen spricht es dann dafür, tatsächlich eine Referenz zu verwenden und nicht einfach einen Pointer (was ich bisher eigentlich grundsätzlich gemacht habe)?

Pointer solltest du nur verwenden, wenn in einer Situation keine Referenzen nutzbar sind:

• das Ziel des Verweises kann sich während seiner Lebenszeit ändern (Anmerkung: das betrifft übrigens keine Funktionsparameter, die bei jedem Aufruf woanders hinzeigen könnten)
• du brauchst eine Möglichkeit, auf "nichts" zu verweisen (es gibt keine NULL-Referenzen
• hinter dem Verweis steckt kein einzelnes Objekt, sondern ein komplettes Array

(btw, ein häufiges Anwendungsfeld von Pointern ist dynamische Speicherverwaltung)

for(unsigned int i = 0; i< a.adjacentFaces.size();i++){
    Face *myFace = &FaceMap[a.adjacentFaces[i]];
	if(a.index == myFace->x){
		if(b.index == myFace->y || b.index == myFace->z){
		FaceMap.erase(i);
		}
		else{
		myFace->x = b.index;
		}
        }
}

Edit: @TLEP: Aus C++ Sicht sind Referenzen "nur" ein Alias für eine andere Variable. Aber der Compiler muß das auch auf eine Art darstellen, die dein Rechner versteht - und wenn der keine eingebauten Referenzen hat, werden dafür hinter den Kulissen wieder Zeiger verwendet.

Nicht unbedingt. In folgendem Code z.B. würde ich erwarten (ungetestet), dass der Compiler bitte *keinen* Zeiger anlegt:

{
    int a = 5;
    int& ra = a;
    ra = 6;
}

Hier einen Zeiger anzulegen ist ein vollkommen unnützes Overhead, 'ra' ist hier ein echtes Alias und der Compiler wird wahrscheinlich für 'ra' dasselbe Symbol wie für 'a' ausspucken und die Initialisierung von 'ra' entfernen.

(Sobald eine neue Stack Frame angelegt wird, geht das natürlich nicht mehr, da muss ein Zeiger erzeugt werden.)

...
In folgendem Code bspw. hätte ich wahrscheinlich eher ne Face-Referenz als nen Face-Pointer verwenden sollen oder ? ...

Naja, das ist ja ein klassisches Beispiel dafür, dass Du eigentlich einen "Alias" (abkürzende Bezeichnung für FaceMap[a.adjacentFaces[i]]) verwenden möchtest. Und genau dafür sind Referenzen ideal.
Mit dem Pointer läufst Du Gefahr, ihn im Code versehentlich "umzubiegen" (auf ein Anderes Objekt oder 0) oder nicht zu wissen, ob Du irgendwas "deleten" musst oder nicht. Besonders über verschiedene Call-Ebenen hinweg wird das schnell zum Problem (z.B. musst Du dann eigentlich immer auf 0 überprüfen).
Das alles sparst Du Dir halt mit einer Referenz.

Gruß,

Simon2.

Frage: Wenn man eine Referenz als Parameter einer Funktion implementiert, werden die Parameter noch auf den Stack gepusht? Würde ja eigentlich keinen Sinn machen.

Das Problem ist doch: was pusht man auf den Stack? Das komplette Objekt? Dann hätte man plötzlich eine Kopie. Man muss also einen Verweis auf das Objekt pushen. Nur welche Möglichkeiten hat man dabei? Man muss eben einen Zeiger auf das Objekt pushen.

CStoll schrieb:

Edit: @TLEP: Aus C++ Sicht sind Referenzen "nur" ein Alias für eine andere Variable. Aber der Compiler muß das auch auf eine Art darstellen, die dein Rechner versteht - und wenn der keine eingebauten Referenzen hat, werden dafür hinter den Kulissen wieder Zeiger verwendet.

Nicht unbedingt. In folgendem Code z.B. würde ich erwarten (ungetestet), dass der Compiler bitte *keinen* Zeiger anlegt:

{
    int a = 5;
    int& ra = a;
    ra = 6;
}

Hier einen Zeiger anzulegen ist ein vollkommen unnützes Overhead,

deswegen wird ein compiler keinen zeiger anlegen, genausowenig wie er das bei

{
    int a = 5;
    int* ra = &a;
    *ra = 6;
}

machen wird.

"Nicht spezifiziert", aber wir können davon ausgehen, dass die meißten Compiler es so machen: http://c-plusplus.net/forum/viewtopic-var-p-is-1330752.html#1330752 ( als Aliase bzw. zweiter Name )