[C++] pointer EN reference (???)

[Verwijderd]

Ik probeer wat code van iemand te ontcijferen, en kom iets tegen waarvan ik echt geen idee heb wat het betekent. Het gaat om de return waarde van onderstaande functie.

code:

MyObject*& MyFunction() {
 
  // code
  return blaat;
}

Is dat nou een reference, een pointer, of ... ???

[Orphix]

Dat is een reference naar een pointer. Erg lelijk ja.

[Verwijderd]

En wat heeft dat voor toegevoegde waarde ?

[Orphix]

Op maandag 20 mei 2002 00:27 schreef delighteddennis het volgende:
En wat heeft dat voor toegevoegde waarde ?

Niks. Ik had nog liever dit gezien

code:

MyObject** MyFunction() {
 
  // code
  return blaat;
}

In feite zou je een reference kunnen beschouwen als een pointer. Echter bij een reference kan je er vrijwel altijd vanuitgaan dat het naar een object wijst. Bij dit soort constructies is het dus erg gemakkelijk om een reference naar een pointer te laten wijzen die nergens naar wijst.

Waarschijnlijk heeft de maker dit gedaan omdat een andere functie een reference naar een pointer vroeg. (maar nogmaals, gebruik dan liever dubbele pointers)

[Verwijderd]

Is het niet zo dat een reference in een return waarde ervoor zorgt dat je het object ook na de return kan behouden. Normaal (als ie bv een int teruggeeft) dan word daar een kopie van gebruikt en daarna weer weggemieterd. Ik moet zeggen dat ik het niet helemaal zeker weer maar volgens mij betekent & het gewoon dat de return waarde in het geheugen blijft totdat je 'm zelf expliciet weggooid.

ik zou graag horen of ik gelijk hebt (of niet natuurlijk)

[Verwijderd]

Op maandag 20 mei 2002 00:31 schreef Orphix het volgende:
Waarschijnlijk heeft de maker dit gedaan omdat een andere functie een reference naar een pointer vroeg. (maar nogmaals, gebruik dan liever dubbele pointers)

Deze constructie kom je vaak tegen in C++. Gebruik er van is meestal een kwestie van smaak, in C++ wordt er normaal zo min mogelijk met "naakte" pointers gewerkt.

Voorbeeldje van waar het moet:

code:

class MyStupidDictionary {
private:
  char *strings[100];

public:
  char*& operator [] (int index) { return strings[index]; }
};

Dit kan dus niet met een pointer, de taal eist een reference.

[MSalters]

Op maandag 20 mei 2002 11:55 schreef unteraarsch het volgende:
Is het niet zo dat een reference in een return waarde ervoor zorgt dat je het object ook na de return kan behouden. Normaal (als ie bv een int teruggeeft) dan word daar een kopie van gebruikt en daarna weer weggemieterd. Ik moet zeggen dat ik het niet helemaal zeker weer maar volgens mij betekent & het gewoon dat de return waarde in het geheugen blijft totdat je 'm zelf expliciet weggooid.

ik zou graag horen of ik gelijk hebt (of niet natuurlijk)

Nee, maar je zit wel buurt.

Normaal maakt de compiler kopieen van return values. Dat betekent dat als je een temporary retourneert de compiler ervoor zorgt dat de waarde bruikbaar blijft.

Als je een reference retourneert maakt de compiler geen kopie. Je bent dan zelf verantwoordelijk voor de lifetime van het origineel c.q. je moet er zelf voor zorgen dat'ie in het geheugen blijft.

[MSalters]

Op maandag 20 mei 2002 00:31 schreef Orphix het volgende:

[..]

Niks. Ik had nog liever dit gezien

code:

MyObject** MyFunction() {
 
  // code
  return blaat;
}

In feite zou je een reference kunnen beschouwen als een pointer. Echter bij een reference kan je er vrijwel altijd vanuitgaan dat het naar een object wijst. Bij dit soort constructies is het dus erg gemakkelijk om een reference naar een pointer te laten wijzen die nergens naar wijst.

Waarschijnlijk heeft de maker dit gedaan omdat een andere functie een reference naar een pointer vroeg. (maar nogmaals, gebruik dan liever dubbele pointers)

** of *& is beide onduidelijk, maar om nou te zeggen dat ** duidelijker is?
Op zich is het helemaal niet erg dat de reference naar pointer een pointer referencet die nergens naar wijst. Je weet namelijk zeker dat

code:

MyObject* ptr = 0;  // of een echt object natuurlijk
MyFunction() = ptr; // Denk NewCallBackObject() = ptr;

goed is; de return value referenced altijd iets waaraan je knt assignen. Met jouw ** versie kan dat niet zeker:
*MyFunction() is misschien een null-pointer dereference.

[Wortelpudding]

Het voordeel van het gebruik van references (hetgeen overigens een C++ feature is), heeft volgens mij het voordeel dat een reference 'strong typed' is.
Pointers kun je in C/C++ altijd typecasten (bijvoorbeeld een char* naar een int*) zonder compiler errors, maar met references gaat dat niet.

Het door elkaar gebruiken van pointers en references werkt idd wel wat verwarrend...

[cobratbq]

Zelf gebruik ik liever references, die zijn voor mij ook wat duidelijker voor te stellen. Al werk ik al een hele tijd met pointers, ik vind het nog steeds een wazig concept. Een reference daarentegen vind ik duidelijker en daar kan ik dan ook makkelijker mee werken.
Maar het is inderdaad een leuke constructie

[Wortelpudding]

Op dinsdag 21 mei 2002 13:56 schreef cobratbq het volgende:
Zelf gebruik ik liever references, die zijn voor mij ook wat duidelijker voor te stellen. Al werk ik al een hele tijd met pointers, ik vind het nog steeds een wazig concept. Een reference daarentegen vind ik duidelijker en daar kan ik dan ook makkelijker mee werken.
Maar het is inderdaad een leuke constructie

Het jammere van references is dat ze in de meeste API's niet gebruikt worden. In veruit de meeste API's moet je toch informatie aan functies doorgeven mbv class- of structpointers

Je kunt dus in je eigen code wel references gaan gebruiken, maar dan zit je dus de hele tijd pointers en references door elkaar te gebruiken. Dat geeft niet echt een overzichtelijk geheel.

[.oisyn]

Op dinsdag 21 mei 2002 14:35 schreef MrHuge het volgende:

[..]

Het jammere van references is dat ze in de meeste API's niet gebruikt worden. In veruit de meeste API's moet je toch informatie aan functies doorgeven mbv class- of structpointers

dat komt omdat die API's gemaakt zijn voor C, niet voor C++. En ze zijn gemaakt voor C omdat je in C geen C++ functies aan kunt roepen, andersom wel

[Wortelpudding]

Op dinsdag 21 mei 2002 14:37 schreef .oisyn het volgende:
dat komt omdat die API's gemaakt zijn voor C, niet voor C++. En ze zijn gemaakt voor C omdat je in C geen C++ functies aan kunt roepen, andersom wel

Hmmm... Er zijn tegenwoordig al heel erg veel API's die met classes werken (denk aan al die API's die op COM objecten gebaseerd zijn), en dus niet met C gebruikt kunnen worden, maar die gebruiken ook nog steeds niet de reference ipv de pointer.

In het geval van COM is deze manier van programmeren natuurlijk door MS opgelegd.

Als je kijkt naar Borland C++ Builder dan zie je dat in de VCL classes eigenlijk alles met de reference gebeurt.

[MSalters]

Op dinsdag 21 mei 2002 10:54 schreef MrHuge het volgende:
Het voordeel van het gebruik van references (hetgeen overigens een C++ feature is), heeft volgens mij het voordeel dat een reference 'strong typed' is.
Pointers kun je in C/C++ altijd typecasten (bijvoorbeeld een char* naar een int*) zonder compiler errors, maar met references gaat dat niet.

Fout gegokt:

code:

char const& rc = 'a';
reinterpret_cast<int&>( rc );

[MSalters]

Op dinsdag 21 mei 2002 14:37 schreef .oisyn het volgende:

[..]

dat komt omdat die API's gemaakt zijn voor C, niet voor C++. En ze zijn gemaakt voor C omdat je in C geen C++ functies aan kunt roepen, andersom wel

Gaat best, zolang de C++ functies maar extern "C" zijn. Maar ze mogen best virtual functies en zo gebruiken.

Evengoed klopt je reden in praktisch opzicht wel; in C kun je nou eenmaal geen references maken.

[.oisyn]

Op dinsdag 21 mei 2002 16:53 schreef MSalters het volgende:

[..]

Gaat best, zolang de C++ functies maar extern "C" zijn. Maar ze mogen best virtual functies en zo gebruiken.

dan zijn het dus gewoon C functies, ook al zijn ze geimplementeerd in C++
wat bedoel je precies met virtual functies?

[MSalters]

Op dinsdag 21 mei 2002 16:57 schreef .oisyn het volgende:

[..]

dan zijn het dus gewoon C functies, ook al zijn ze geimplementeerd in C++
wat bedoel je precies met virtual functies?

class C
{
virtual ~C() { ... }
}

Die mag je dus best aanroepen vanuit een extern "C" foo() functie. Maar om foo() dan een C functie te noemen?

[nhimf]

zoals al eerder gezegd is: &* is een referente pointer.

Waarom zou je dat willen? Nou simpel, als je wilt dat de pointer naar een ander geheugen adres gaat wijzen.
Als je veel met dynamisch geheugen werkt kom je dit vaak tegen.

Er zijn mensen die dit ** prefereren, maar in weze is dit langzamer, omdat je met een referentie in 1x het goede geheugen gebied te pakken hep en met een pointer moet je eerst de variabele uitlezen en dan hep je pas het geheugen adres te pakken.

Als je prog erg afhankelijk is van de snelheid kan je beter &* gebruiken ipv **.

btw ** gebruik je meestal voor een array van pointers.

[.oisyn]

Op dinsdag 21 mei 2002 17:26 schreef MSalters het volgende:

[..]

class C
{
virtual ~C() { ... }
}

Die mag je dus best aanroepen vanuit een extern "C" foo() functie. Maar om foo() dan een C functie te noemen?

oh bedoel je het zo
maar zoals ik al zei: de implementatie is gewoon in C++, naar buiten toe zijn het echter C functies

[Orphix]

Op dinsdag 21 mei 2002 17:31 schreef nhimf het volgende:
zoals al eerder gezegd is: &* is een referente pointer.

Waarom zou je dat willen? Nou simpel, als je wilt dat de pointer naar een ander geheugen adres gaat wijzen.
Als je veel met dynamisch geheugen werkt kom je dit vaak tegen.

Er zijn mensen die dit ** prefereren, maar in weze is dit langzamer, omdat je met een referentie in 1x het goede geheugen gebied te pakken hep en met een pointer moet je eerst de variabele uitlezen en dan hep je pas het geheugen adres te pakken.

Als je prog erg afhankelijk is van de snelheid kan je beter &* gebruiken ipv **.

btw ** gebruik je meestal voor een array van pointers.

Uh sneller? Ik denk dat je hiermee bedoelt dat bij compilen de adressen van statische objecten kan worden ingevuld?

Ik vraag me zeer af of een dubbele pointer bij dynamische gebruik langzamer is dan references.

Op dinsdag 21 mei 2002 10:39 schreef MSalters het volgende:
** of *& is beide onduidelijk, maar om nou te zeggen dat ** duidelijker is?

Achja zal misschien wel smaak zijn. (ik schrijf btw ook liever int main(int argc, char *argv[]) ipv de dubbele pointers).
Ik heb zelf nog nooit deze constructies gebruikt. Bij references ga ik er, misschien fout, onbewust van uit dat er direct een object aan hangt.

Op zich is het helemaal niet erg dat de reference naar pointer een pointer referencet die nergens naar wijst. Je weet namelijk zeker dat

code:

MyObject* ptr = 0;  // of een echt object natuurlijk
MyFunction() = ptr; // Denk NewCallBackObject() = ptr;

goed is; de return value referenced altijd iets waaraan je knt assignen. Met jouw ** versie kan dat niet zeker:
*MyFunction() is misschien een null-pointer dereference.

Tja maar om nou return-references te gebruiken om waardes mee te geven aan object/functie vind ik zowiezo al erg

[Verwijderd]

Op dinsdag 21 mei 2002 17:31 schreef nhimf het volgende:

zoals al eerder gezegd is: &* is een referente pointer.
Waarom zou je dat willen? Nou simpel, als je wilt dat de pointer naar een ander geheugen adres gaat wijzen.
Als je veel met dynamisch geheugen werkt kom je dit vaak tegen.

Maar je kan natuurlijk ook gewoon de pointer aanpassen. Zie in dit geval het nut van de extra reference niet.

Op dinsdag 21 mei 2002 19:30 schreef Orphix het volgende:


Bij references ga ik er, misschien fout, onbewust van uit dat er direct een object aan hangt.

Ik dacht dat dat juist een eigenschap van references is.

[Orphix]

Op dinsdag 21 mei 2002 19:51 schreef delighteddennis het volgende:
Ik dacht dat dat juist een eigenschap van references is.

Een reference kan zoals in dit geval ook voor pointer spelen.

[Verwijderd]

tuurlijk... dom... dom.. dom.