Ab wann lohnen sich Referenzen?

Korbinian

vorsicht, nicht pauschalisieren. du darfst natürlich nicht vergessen, dass du bei übergebener referenz das objekt selbst veränderst, und nicht eine kopie! möchtest du das nicht, musst du eine kopie übergeben.

// nur zur erinnerung
int machWasMitArray(int intArray[], int len)
{
    if (len < 1)
        return 0;
    intArray[0] = 10;
    return 1;
}
int machWasMitReferenz(std::string &strReference)
{
    strReference = "Huhu";
    return 1;
}

int main()
{
    int intArray[2] = { 0, 0 };
    std::string myString(Hallo);
    machWasMitArray(intArray);
    machWasMitReferenz(myString);
    // Jetzt ist intArray[0] == 10 und myString == "Huhu"
    // in C/C++ werden Arrays automatisch by reference übergeben
}

ChrisM

Hi,

deswegen übergibt man ja nur const-Referenzen, es sei denn, man möchte das Objekt verändern und es steht in der Dokumentation, dass die Funktion den Wert eines Parameters ändert!

ChrisM

Korbinian

ChrisM schrieb:

...deswegen übergibt man ja nur const-Referenzen, es sei denn, man möchte das Objekt verändern...

dachte es geht um referenzen allgemein . es passiert aber doch öfters, dass man ads const vergisst, und sich dann wundert, warums nicht geht.

peterchen

passiert aber doch öfters, dass man ads const vergisst, und sich dann wundert, warums nicht geht

Hmm... mir nicht

ChrisM

Hi,

ich hab mir const std::string& zu schreiben schon so angewöhnt... meinem Auge würde was fehlen, wenn das const weg wäre.

Außerdem kann man sich ja zur Hilfe sowas machen:
typedef MyStringRef const std::string&

ChrisM

Wenn ich das richtig verstanden habe spart man mit referenzen ja auch Speicherplaz(=Aliasname) also ist Call by Reference hier besser als Call by Value:
Bei Call by Value wird ja eine Kopie erzeugt, obwohl es die Variable ja schon in der main gibt.

Die Call by Reference Funktion:

inline void Addition(double& Ergebnis,const float& Zahl1,const float& Zahl2){

		Ergebnis=(Zahl1+Zahl2);

	}

Die Call by Value:

inline double Addition(float Zahl1,float Zahl2){
double Ergebnis;
       Ergebnis=(Zahl1+Zahl2);
return Ergebnis;
}

Die Call by Reference müsste ja schneller sein oder?

cu max

Hi,

der titel sagt alles:

int Position = 3;

MyVector.erase (&MyVector[Position]); 

MyVector.erase( MyVector.begin() + Position);

und nun meine frage: sind die beiden Mehtoden Legal, Illegal oder Äquivalent?

Knuddlbaer

http://c-plusplus.net/forum/viewtopic.php?t=60028&sid=48543a0e82bcb30a8d7fbf00df8615fe

Shade Of Mine

Master_Max schrieb:

Die Call by Reference müsste ja schneller sein oder?

Nein, langsamer. Denn Referenzen werden intern quasi immer mit Zeigern implementiert. Das bedeutet, dass du jedesmal wenn du zb Ergebnis ansprichst eine Dereferenzierung machst - also hast du Mehrkosten ohne Performace Vorteil bei der Übergabe.

Vellas

Shade Of Mine schrieb:

Nein, langsamer. Denn Referenzen werden intern quasi immer mit Zeigern implementiert. Das bedeutet, dass du jedesmal wenn du zb Ergebnis ansprichst eine Dereferenzierung machst - also hast du Mehrkosten ohne Performace Vorteil bei der Übergabe.

Gilt das auch für eigene Klassen/Strukturen oder beziehst du dich da jetzt auf die vordefinierten Datentypen? Wenn das allerdings allgemein gilt, wozu sollte ich dann eine Referenz benutzen, wenn sie langsamer ist (außer wenn ich das Objekt selbst verändern möchte)?

Code-Hacker

Shade Of Mine

Du gehst hier von falschen Dimensionen aus.

Eine Referenz ist im Prinzip ein konstanter Zeiger. Folglich muss bei jedem Zugriff auf das referenzierte Objekte eine Dereferenzierung erfolgen. Bei Zeigern sieht man es schön:

*p=3;
bei Referenzen nicht
r=3;

Ich wollte hier lediglich darauf hinweisen, dass es keinen Sinn macht alles by reference zu übergeben, denn gratis gibt es garnichts.

Allerdings kostet eine Dereferenzierung nun wirklich sehr wenig Zeit, das kopieren eines String dauert unendlich länger.

Ich wollte hiermit nur den Grund aufführen warum man Builtins by value übergibt. Über den Daumen rechnet man
wenn sizeof(T) > 2*sizeof(void*) dann per Referenz.

Vellas

OK, danke.

Code-Hacker

Aha, danke.

cu max

Gerard

Shade Of Mine schrieb:

Master_Max schrieb:

Die Call by Reference müsste ja schneller sein oder?

Nein, langsamer. Denn Referenzen werden intern quasi immer mit Zeigern implementiert. Das bedeutet, dass du jedesmal wenn du zb Ergebnis ansprichst eine Dereferenzierung machst - also hast du Mehrkosten ohne Performace Vorteil bei der Übergabe.

das ist wohl implemetierungs abhänig, bei heutigen compilier wirst du wahrscheinlich schwierigkeiten haben ein unterschied zwischen call by value und call by referenz fest zu stellen (bei buildins)

Shade Of Mine schrieb:

Ich wollte hiermit nur den Grund aufführen warum man Builtins by value übergibt. Über den Daumen rechnet man
wenn sizeof(T) > 2*sizeof(void*) dann per Referenz.

mach ein speed test, du kannst alles per referenz übergeben, der compilier wirds schon richten