[C++] Newbie vraag: waarom pointers?

[Battle Bunny]

Eindelijk ben ik dan C++ aan het leren! Nogal wennen vanaf Visual Basic, maar het lukt. Er is alleen iets wat ik écht niet snap, en dat zijn die pointers. Ik weet wel hoe je ze moet toepassen, maar waarom zou ik dat in godsnaam doen? Als ik een variabele heb met een waarde erin, kan ik toch net zo goed

code:

myvar = myvar * 10;

roepen? Dan hoef ik toch niet met een pointer te werken?

Ik heb al gezocht met goochel en hier, maar kon niets (of eigenlijk teveel) vinden.

[Expecho]

Standaard voorbeeld: Probeer jij maar eens een functie te maken die 2 variablen teruggeeft, dat lukt niet en dan komen pointers goed van pas.

[Wirf]

het doorgeven van een pointer is ook veel sneller dan het doorgeven van het hele object

en als je 1 variabele hebt die onder meerdere threads hetzelfde moet zijn komt het ook erg goed van pas

[Verwijderd]

Aangezien je al vb kent, is jouw vraag op te lossen met het zelfde antwoord op de vraag "Waarom zou je je paramters in vb byref doorgeven?"

[Battle Bunny]

Dus je kan in princiepe gewoon een int teruggeven, maar TOCH meerdere vars doorgeven? En dat zonder een struct?

[Battle Bunny]

Aangezien je al vb kent, is jouw vraag op te lossen met het zelfde antwoord op de vraag "Waarom zou je je paramters in vb byref doorgeven?"

Daar heb ik me, eerlijk gezegt, nooit in verdiept...

EDIT: byref/byval, that is.

[Verwijderd]

Op woensdag 15 mei 2002 14:58 schreef Expecho het volgende:
Standaard voorbeeld: Probeer jij maar eens een functie te maken die 2 variablen teruggeeft, dat lukt niet en dan komen pointers goed van pas.

Dat doe je niet met pointers maar met references in C++. Dus zo:

code:

void doe_iets(int& a, int& b) {
  a= 1, b= 2;
}

Pointers in C++ gebruik je in principe om nieuwe objecten aan te maken, dus:

code:

int *p= new int;

Voor de rest kun je ze net als in C gebruiken om elementen van datacollecties (bv. arrays of linked lists) door te lopen.

[Hu9o]

Op woensdag 15 mei 2002 14:58 schreef Expecho het volgende:
Standaard voorbeeld: Probeer jij maar eens een functie te maken die 2 variablen teruggeeft, dat lukt niet en dan komen pointers goed van pas.

Kan dat niet en C++ ?? Ik ken de taal niet. Maar het lijkt me sterk eigelijk. In Delphi kan dat heel makkelijk.

code:

Function NaamVanFunctie(var GeefTerug:String;HebNodig:String):Boolean.

Deze heeft een string nodig, levert een string terug en een boolean. Dus 2 variabelen.

[ritsjoena]

Voor dit soort grapje gebruik ik ze meestal ook niet. Maar voor de volgende gevallen zijn ze wel handig:
(NB ik programmeer alleen in ANSI C)

1) Doorgeven van variabelen aan functies. Voor C geldt (weet niet of ook voor C++) dat als je een variabele aan een functie doorgeeft, er een kopie gemaakt wordt van die variabele en hiermee doet de functie alles. Als je dus iets wilt wijzigen in de oorspronkelijke variabele, moet je daarvan het adres en niet de waarde doorgeven. I.e. een pointer.

Met variabele bedoel ik alles van een getal/char/structure/array/pointer etc.

Hier ontkom je er dus niet aan om pointers te gebruiken.

2) Als je met grote structuren werkt (bv arrays) is het handiger om een pointer naar de structuur aan de functie door te geven, ipv dat deze een kopie moet maken van je hele structure.

3) Pointers zijn erg handig om mee door bv een array heen te lopen.

4) Je kunt pointers gebruiken om dynamische structuren te maken. Als bv een lijst:

typedef stuct list_t {
char *data;
list_t *volgende;
list_t *vorige;
} list_t;

Het maakt hierbij niet uit hoe veel elementen je hebt, je kunt er altijd meer toevoegen en ook routines voor tussenvoegen zijn eenvoudig.

5) Veel dingen (bv door array lopen) gaan met pointers veel sneller (minder instructies) dan op elke andere manier zonder pointers.

In de korte tijd die ik in deze reactie stop vergeet ik er vast wel een paar.

Pointers zijn even wennen en hoewel het waarschijnlijk mogelijk is om vrijwel alles zonder pointers te doen, is het zeker de moeite waard om er goed mee om te leren gaan. Je code wordt er overzichtelijker van en een heleboel problemen zijn ineens een stuk eenvoudiger op te lossen met pointers.

Doch ik moet je er wel even sterkte mee wensen alhoewel het uiteindelijk allemaal wel mee zal vallen hoor.

[Battle Bunny]

Aangezien het behoorlijk CPU intensief zal worden, lijkt het me handig dat ik die malle puntjes ga gebruiken. Ik dank u allen zeer voor deze les (en zal het meteen gaan toepassen)!

[Verwijderd]

Op woensdag 15 mei 2002 15:10 schreef ritsjoena het volgende:
1) Doorgeven van variabelen aan functies. Voor C geldt (weet niet of ook voor C++) dat als je een variabele aan een functie doorgeeft, er een kopie gemaakt wordt van die variabele en hiermee doet de functie alles. Als je dus iets wilt wijzigen in de oorspronkelijke variabele, moet je daarvan het adres en niet de waarde doorgeven. I.e. een pointer.

Klopt, C++ gebruikt net als C standaard call-by-value. Alleen kent C++ de reference, en is het dus een slechte gewoonte om in C++ call-by-reference dmv. pointers te implementeren (zie boven).

[Battle Bunny]

Klopt, C++ gebruikt net als C standaard call-by-value. Alleen kent C++ de reference, en is het dus een slechte gewoonte om in C++ call-by-reference dmv. pointers te implementeren (zie boven).

Wow... Deze vat ik niet helemaal. Volgens jou is het dus NIET handig om functies aan te roepen met pointers?

[ritsjoena]

[..]

Wow... Deze vat ik niet helemaal. Volgens jou is het dus NIET handig om functies aan te roepen met pointers?

Als ik het uit het bovenstaande goed begrijp heeft C++ een andere methode om gegevens aan een functie door te geven ( call-by-reference) , waardoor je voor dit doel geen pointers meer hoeft te gebruiken, maar voor andere toepassingen gaat dit niet op.

Het zou me trouwens niet verbazen als dit niet meer is dan een pointer in een jasje, waardoor je hem als normale variabele kan gebruiken.

[.oisyn]

Op woensdag 15 mei 2002 15:18 schreef mietje het volgende:

[..]

Klopt, C++ gebruikt net als C standaard call-by-value. Alleen kent C++ de reference, en is het dus een slechte gewoonte om in C++ call-by-reference dmv. pointers te implementeren (zie boven).

Nah, pointers zijn nog altijd handig als een bepaald resultaat niet gewenst is, dan kun je gewoon een null-pointer meegeven. Er is dus niets slechts aan

[MSalters]

Op woensdag 15 mei 2002 14:58 schreef Expecho het volgende:
Standaard voorbeeld: Probeer jij maar eens een functie te maken die 2 variablen teruggeeft, dat lukt niet en dan komen pointers goed van pas.

Laten we't eens proberen:

code:

using namespace std;

pair<int, string> foo( int a, string b )
{
  return make_pair( a+2, b+"!" );
}

Geen pointer gezien.

[LegacyCode]

Pointers zijn zeer handig als je met arrays (rijen) gaat werken. Een string bijvoorbeeld is in C++ een array van allemaal chars.
Als je dan een functie zou moeten schrijven om bijvoorbeeld te tellen hoe vaak een bepaalde letter in die string voorkomt.
Geef je gewoon de pointer door naar die functie.
En laat dan steeds die pointer met 1 ophogen voor t volgende teken in die string.
Met pointers gaat je programma ook minder geheugen vreten, je verwijst gewoon naar de data ipv n kopie te maken van de data.

[Verwijderd]

Op woensdag 15 mei 2002 16:13 schreef .oisyn het volgende:
Nah, pointers zijn nog altijd handig als een bepaald resultaat niet gewenst is, dan kun je gewoon een null-pointer meegeven. Er is dus niets slechts aan

Hehe, je blijft toch een ouwe C-rakker

Het passen van magic-cookies (zoals bv. null-pointers) om errors te indiceren is simpelweg not done in C++.

In C++ gebruik je daarvoor exceptions. Exceptions kun je ook niet vergeten af te vragen, en je loopt dus geen kans meer op segfaults door het dereferencen van null-pointers.

[Verwijderd]

Oeps, deze heb ik gemist.

Op woensdag 15 mei 2002 15:33 schreef ritsjoena het volgende:
Als ik het uit het bovenstaande goed begrijp heeft C++ een andere methode om gegevens aan een functie door te geven ( call-by-reference) , waardoor je voor dit doel geen pointers meer hoeft te gebruiken, maar voor andere toepassingen gaat dit niet op.

Exact, C++ heeft een aparte construct daarvoor; de reference, aangegeven met een &.

code:

void pass_by_value(int a, int b);

void pass_by_reference(int& a, int& b);

Het zou me trouwens niet verbazen als dit niet meer is dan een pointer in een jasje, waardoor je hem als normale variabele kan gebruiken.

Precies, je hoeft een reference niet te dereferencen zoals een pointer (met een *). Maar het belangrijkste verschil is dat een reference altijd naar een geldig geheugenadres wijst. Null-references zijn dus onmogelijk, en dat voorkomt een hoop bugs (zie vorige post).

[Verwijderd]

Op woensdag 15 mei 2002 16:55 schreef mietje het volgende:
Maar het belangrijkste verschil is dat een reference altijd naar een geldig geheugenadres wijst. Null-references zijn dus onmogelijk, en dat voorkomt een hoop bugs (zie vorige post).

Fout:

code:

int & i = *((int*)0);

Een reference initialiseren met een gedereference'te pointer komt best af en toe voor.

[Tim]

Op woensdag 15 mei 2002 17:05 schreef Sneechy het volgende:

[..]

Fout:

code:

int & i = *((int*)0);

Een reference initialiseren met een gedereference'te pointer komt best af en toe voor.

En wat is het nut daarvan?

[whoami]

Pointers kun je dus gebruiken (zoals al eerder gezegd werd) om een functie meerdere waardes te laten teruggeven (alhoewel references daarvoor in C++ geprefereerd worden). Je kan pointers ook gebruiken om dynamisch objecten of arrays te creeëren.

Iets wat nog niet genoemd is, maar wel handig kan zijn, zijn functie pointers. Je pointer wijst dan niet naar een variable, maar naar een functie.

[Orphix]

Op woensdag 15 mei 2002 17:05 schreef Sneechy het volgende:
Een reference initialiseren met een gedereference'te pointer komt best af en toe voor.

Ja in jouw code zeker

Dit is dus imho een paardenmiddel en niet mooi programmeerwerk.

[Verwijderd]

Op woensdag 15 mei 2002 18:43 schreef Orphix het volgende:
Dit is dus imho een paardenmiddel en niet mooi programmeerwerk.

Voorbeeld:

Als je een int* hebt verkregen met een new call en er vervolgens void f (int&) mee wil aanroepen, heb je zo'n conversie nodig.

Pointer->reference conversies zijn dus af en toe gewoon nodig, en hebben niks met paardenmiddelen te maken.

[.oisyn]

Op woensdag 15 mei 2002 16:41 schreef mietje het volgende:

[..]

Hehe, je blijft toch een ouwe C-rakker

idd

Het passen van magic-cookies (zoals bv. null-pointers) om errors te indiceren is simpelweg not done in C++.

In C++ gebruik je daarvoor exceptions. Exceptions kun je ook niet vergeten af te vragen, en je loopt dus geen kans meer op segfaults door het dereferencen van null-pointers.

Dat is niet wat ik bedoelde. Ik bedoelde een functieaanroep waarbij je meerdere resultaten opvraagt. Als dan niet alle resultaten gewenst zijn, dan kun je een null-pointer meegeven.

Neem bijvoorbeeld de Win32 API functie ScrollWindowEx:

code:

int ScrollWindowEx(
  HWND hWnd,         // handle to window
  int dx,           // horizontal scrolling
  int dy,           // vertical scrolling
  CONST RECT *prcScroll, // client area
  CONST RECT *prcClip,   // clipping rectangle
  HRGN hrgnUpdate,   // handle to update region
  LPRECT prcUpdate, // invalidated region
  UINT flags         // scrolling options
);

prcScroll en prcClip zou in C++ idd een referentie moeten zijn, maar hrgnUpdate en prcUpdate zijn optioneel

(voor de mensen die het niet weten: HRGN is gedefinieerd als struct HRGN__ *, en LPRECT als RECT *)

Als je NULL invoert, dan worden ze ook niet gevuld met data. Wil je echter wel die data ontvangen, dan zul je dus ook een geldige pointer mee moeten geven.
Als het referenties waren geweest heb je die keuze niet (ja je kan er vies omheen door bijvoorbeeld *(KlasseNaam *)0 van te maken, maar dat is natuurlijk helemaal foute boel )


natuurlijk komen dit soort dingen niet vaak voor, maar wat ik probeerde aan te geven is dat pointers als functievariabelen niet per definitie slecht zijn in C++

[Primal]

Op woensdag 15 mei 2002 19:22 schreef Sneechy het volgende:

[..]

Voorbeeld:

Als je een int* hebt verkregen met een new call en er vervolgens void f (int&) mee wil aanroepen, heb je zo'n conversie nodig.

Pointer->reference conversies zijn dus af en toe gewoon nodig, en hebben niks met paardenmiddelen te maken.

Hmmm, de term compiler confusion komt hier niet op zijn plaats. Ik zou het eerder hebben over programmer confusion.

Even serieus, persoonlijk kies ik er altijd voor dit soort dingen te vermijden. Ik vind het gewoon niet snel/makkelijk lezen, als je dergelijke stijl veel gebruikt. Als je het spaarzaam hier en daar gebruikt (wat dus ook wel het geval is, maar toch ) dan vind ik het niet zo erg. Maar ik maak er dus echt geen gewoonte van.

[Verwijderd]

Op woensdag 15 mei 2002 16:41 schreef mietje het volgende:
Het passen van magic-cookies (zoals bv. null-pointers) om errors te indiceren is simpelweg not done in C++.

In C++ gebruik je daarvoor exceptions. Exceptions kun je ook niet vergeten af te vragen, en je loopt dus geen kans meer op segfaults door het dereferencen van null-pointers.

Oeps, iets te veel Java gebruikt denk ik... In C++ kan je excepties helaas wel vergeten (de try-catch eromheen dus) zonder dat de compiler gaat zeuren (bij MSVC++ in ieder geval).
Verder is op dit moment volgens mij toch echt het gebruik van NULL's en zo echt wel 'normaal' en is het exceptie gebruik eerder 'not done', wat overigens absoluut betekend dat ik dit beter vindt of zo, maar gewoon een observatie is uit de praktijk.

[.oisyn]

idd, exceptions gebruik je voor exceptions: uitzonderingen dus. En die moet je dus ook niet gebruiken voor normale program flow

Wat je natuurlijk wel kunt doen voor 'speciale' pointers is bepaalde constante instanties maken en die gebruiken (zal vast wel een naam voor zijn, maar die is me even ontschoten )

dit zeg maar:

code:

class Blaat
{
    //... wat declaraties enzo
public:
    static const Blaat none;
};

void functie (Blaat & b)
{
    if (b == Blaat::none)
    {
    }
    else
    {
    }
}

int main ()
{
    Blaat b;

    functie (b);
    functie (Blaat::none);
}

dan heb je ook wat meer opties dan alleen een NULL pointer

[MSalters]

Op woensdag 15 mei 2002 22:33 schreef .oisyn het volgende:
Wat je natuurlijk wel kunt doen voor 'speciale' pointers is bepaalde constante instanties maken en die gebruiken (zal vast wel een naam voor zijn, maar die is me even ontschoten )

"singular"

[Soultaker]

Op woensdag 15 mei 2002 22:33 schreef .oisyn het volgende:
Wat je natuurlijk wel kunt doen voor 'speciale' pointers is bepaalde constante instanties maken en die gebruiken (zal vast wel een naam voor zijn, maar die is me even ontschoten )

Dus omdat JOU functie ook null moet kunnen accepteren moet MIJN klasse een bepaalde constante bevatten? Of suggereer je nu dat ALLE klassen zo'n constante zouden moeten bevatten (waardoor het dus een soort Class::null zou worden)? Dat vind ik niet echt mooi ontwerp en dat heeft gelijk als gevolg dat alle klassen op een zinnige manier geinitialisieerd moeten kunnen worden (met een constructor zonder parameters bijvoorbeeld). Vaak is dat niet mogelijk; denk bijvoorbeeld aan een begrip als een 'connectie' of een 'email adres'.

Het is niet ongebruikelijk dat je een functie die een paramter wel of niet mag hebben opsplitst in twee functies, waarvan de een parameter minder heeft dan de ander.

Sowieso is het vaak onwenselijk en altijd onnodig om klassen by-value door te geven (en dat wordt in talen als Java en SmallTalk dan ook nooit gedaan) dus in dat geval is een NULL pointer geen enkel bezwaar.

[.oisyn]

je begrijpt me verkeerd. Misschien had ik die functie beter een static member van Blaat kunnen maken (lees trouwens de topic, ik was nog altijd degene die zei dat een null pointer niet per definitie fout was in c++)

En nu je het toch over java hebt; daarin komen singulars _{bedankt MSalters} juist heel veel voor

[whoami]

Nog een feature die mogelijk gemaakt wordt dmv pointers te gebruiken: polymorphism.

[farlane]

Of de welbekende functiepointers in C(++). ( Die polymorfisme mogelijk maakt )

[whoami]

Op donderdag 16 mei 2002 12:39 schreef farlane het volgende:
Of de welbekende functiepointers in C(++). ( Die polymorfisme mogelijk maakt )

Functiepointers hebben imho niet als doel om polymorphisme mogelijk te maken. Virtual functions zorgen daarvoor, of mis ik iets?

[farlane]

Functiepointers hebben imho niet als doel om polymorphisme mogelijk te maken. Virtual functions zorgen daarvoor, of mis ik iets?

Functiepointers hebben niet speciaal dat als doel, maar de VTABLE in een klasse, die met pointers naar die functies gevuld wordt, maakt wel polymorfisme mogelijk.

[Soultaker]

Op donderdag 16 mei 2002 12:42 schreef whoami het volgende:
Functiepointers hebben imho niet als doel om polymorphisme mogelijk te maken. Virtual functions zorgen daarvoor, of mis ik iets?

In C beschik je daar natuurlijk niet over, maar inderdaad, met virtual functions heb je in principe geen functiepointers meer nodig. Ze worden in een OO-omgeving dan ook weinig (if at all) gebruikt.

[whoami]

Op donderdag 16 mei 2002 12:57 schreef Soultaker het volgende:


In C beschik je daar natuurlijk niet over, maar inderdaad, met virtual functions heb je in principe geen functiepointers meer nodig. Ze worden in een OO-omgeving dan ook weinig (if at all) gebruikt.

Hmm, daar ga ik niet zo mee akkoord. Functie-pointers kunnen ook in een OO omgeving nog altijd zeer handig zijn. Als je bv 2 objecten hebt, en het ene object moet een operatie uitvoeren op de gegevens van dat ander object kan je functie-pointers gebruiken.
Ook voor communicatie tussen 2 forms kun je functie-pointers gebruiken.

In .NET hebben ze nu zelfs een OO-oplossing gevonden voor functie-pointers nl. delegates.

[Verwijderd]

Op donderdag 16 mei 2002 12:57 schreef Soultaker het volgende:

[..]

In C beschik je daar natuurlijk niet over, maar inderdaad, met virtual functions heb je in principe geen functiepointers meer nodig. Ze worden in een OO-omgeving dan ook weinig (if at all) gebruikt.

Hier ben ik het niet mee eens. Functiepointers (of eigenlijk function objects in het algemeen) blijven ideaal voor het 'customizen' van allerlei general purpose algoritmen en structuren. Ook de C++ Standard Library maakt hier veelvuldig gebruik van.

[mbravenboer]

Sneechy: Functiepointers blijven ideaal voor het 'customizen' van allerlei general purpose algoritmen en structuren. Ook de C++ Standard Library maakt hier veelvuldig gebruik van.

Hier worden in Java kleine interfaces voor gebruikt zoals Comparator en dergelijke. Het aardige van deze aanpak tov van delegates is dat je ook gelijk aangeeft wat de functionaliteit van een klasse is door het implementeren van de interface.

[whoami]

Op donderdag 16 mei 2002 13:19 schreef mbravenboer het volgende:


Hier worden in Java kleine interfaces voor gebruikt zoals Comparator en dergelijke. Het aardige van deze aanpak tov van delegates is dat je ook gelijk aangeeft wat de functionaliteit van een klasse is door het implementeren van de interface.

Java, bah.
Kun je dit even verder toelichten, want ik zie niet direct een verband tussen een delegate en een interface. Ik denk niet dat je met een interface evenveel kunt als met een delegate.

[Verwijderd]

Op donderdag 16 mei 2002 13:19 schreef mbravenboer het volgende:

[..]

Hier worden in Java kleine interfaces voor gebruikt zoals Comparator en dergelijke. Het aardige van deze aanpak tov van delegates is dat je ook gelijk aangeeft wat de functionaliteit van een klasse is door het implementeren van de interface.

In C++ is een function object simpelweg iets dat je aan kan roepen met een aantal parameters, en dat optioneel een waarde returned. Het voordeel van deze definitie is dat 'native' function pointers of references ook als function objects gebruikt kunnen worden.

Het verband met delegates zie ik eigenlijk niet helemaal..

[whoami]

Op donderdag 16 mei 2002 13:39 schreef Sneechy het volgende:

Het verband met delegates zie ik eigenlijk niet helemaal..

Sterker zelfs, ik zie het helemaal niet.

[Soultaker]

Op donderdag 16 mei 2002 13:16 schreef Sneechy het volgende:
Hier ben ik het niet mee eens. Functiepointers (of eigenlijk function objects in het algemeen) blijven ideaal voor het 'customizen' van allerlei general purpose algoritmen en structuren.

Ik zei alleen dat je ze niet meer nodig had en dat ze in veel OO-toepassingen daarom ook niet gebruikt worden. De C++ STL is inderdaad een voorbeeld van een nogal C-achtige library die dus wel van functionpointers gebruik maakt.

[whoami]

Op donderdag 16 mei 2002 13:59 schreef Soultaker het volgende:

Ik zei alleen dat je ze niet meer nodig had en dat ze in veel OO-toepassingen daarom ook niet gebruikt worden. De C++ STL is inderdaad een voorbeeld van een nogal C-achtige library die dus wel van functionpointers gebruik maakt.

Toch heb je functie pointers wel nog nodig. Het event-model van Delphi bv werkt op basis van functie-pointers. (Net als het event-model in .NET trouwens, maar daar hebben ze dus die OO-structuur voor gemaakt)
En je kan het ook nog in tal van andere situaties gebruiken.

Edit: Maar voor polymorphisme heb je ze idd niet meer nodig. (En ik denk dat je dat wou zeggen)

[Verwijderd]

Op donderdag 16 mei 2002 13:59 schreef Soultaker het volgende:
De C++ STL is inderdaad een voorbeeld van een nogal C-achtige library die dus wel van functionpointers gebruik maakt.

Uhmm..

Maar neem nou een mooi voorbeeld als dit:

code:

template<class InIt, class Pr> InIt find_if(InIt first, InIt last, Pr pred);
/*
The template function determines the lowest value
of N in the range [0, last - first) for which the
predicate pred(*(first + N)) is true. It then
returns first + N.
*/

Dit find algoritme is te customizen m.b.v. een predicate function object.

Wat is hier nou eigenlijk mis mee ?

[Verwijderd]

Op woensdag 15 mei 2002 20:49 schreef .oisyn het volgende:
Dat is niet wat ik bedoelde. Ik bedoelde een functieaanroep waarbij je meerdere resultaten opvraagt. Als dan niet alle resultaten gewenst zijn, dan kun je een null-pointer meegeven.

Achso, vestanden Agreed, dit is een mogelijkheid, hoeqwel er ook nettere manieren zijn om dit op te lossen.

Als het referenties waren geweest heb je die keuze niet (ja je kan er vies omheen door bijvoorbeeld *(KlasseNaam *)0 van te maken, maar dat is natuurlijk helemaal foute boel )

Daarom reageer ik niet op Sneetchies post

natuurlijk komen dit soort dingen niet vaak voor, maar wat ik probeerde aan te geven is dat pointers als functievariabelen niet per definitie slecht zijn in C++

Klopt wel, er zijn speciale gevallen denkbaar waar je er niet of moeilijk omheen komt. Maar een normale praktijk is het iig. niet.

Op woensdag 15 mei 2002 21:47 schreef hondass50 het volgende:
Oeps, iets te veel Java gebruikt denk ik... In C++ kan je excepties helaas wel vergeten (de try-catch eromheen dus) zonder dat de compiler gaat zeuren (bij MSVC++ in ieder geval).

Ik gebruik geen java...

Als je een try/catch block vergeet, dan zal je programma aborten (met een exit(1) en een foutmelding), maar er zullen geen segfaults optreden.

Verder is op dit moment volgens mij toch echt het gebruik van NULL's en zo echt wel 'normaal' en is het exceptie gebruik eerder 'not done', wat overigens absoluut betekend dat ik dit beter vindt of zo, maar gewoon een observatie is uit de praktijk.

Helaas zijn er ontzettend veel houthakkers die keihard C-style code schrijven en beweren dat het goed C++ design is.

Ik probeer met mijn posts mensen ertoe te brengen C++ te gebruiken zoals het bedoeld is. Dat betekent dus dat je meer discipline moet hebben dan in C, maar dat je er ook meer voor terugkrijgt.

Er zijn hier ook wat vertegenwoordigers van het andere "alles kan, niets moet" kamp, die ik het bekende citaat van Stroustrupp wil voorhouden: "in C it's fairly easy to "shoot yourself in the foot" (metaphorically speaking), whereas in C++ it's harder to shoot yourself in the foot, but when you do, you usually blow your whole leg off."

[Orphix]

Op woensdag 15 mei 2002 19:22 schreef Sneechy het volgende:
Pointer->reference conversies zijn dus af en toe gewoon nodig, en hebben niks met paardenmiddelen te maken.

Ja dit is logisch. De-referencen moet altijd kunnen. Maar expres een NULL waarde initialiseren en daar vervolgens een reference van maken (of begrijp ik het nou verkeerd ) is vragen om problemen.

[Verwijderd]

Op donderdag 16 mei 2002 19:20 schreef Orphix het volgende:

[..]

Ja dit is logisch. De-referencen moet altijd kunnen. Maar expres een NULL waarde initialiseren en daar vervolgens een reference van maken (of begrijp ik het nou verkeerd ) is vragen om problemen.

Dat soort praktijken zijn inderdaad niet erg algemeen geaccepteerd .

Ik wilde alleen even mietje's foute uitspraak:

... een reference altijd naar een geldig geheugenadres wijst. Null-references zijn dus onmogelijk ...

met een voorbeeld weerleggen.

[mbravenboer]

Het verband tussen interfaces en delegates? Nou ja, dat lijkt mij eigenlijk wel duidelijk . In Java worden heel veel interfaces gebruikt voor zaken waarbij je in talen met delegates zou kunnen werken. Ik noemde als voorbeeld de Comparator, maar een ander voorbeeld is de ActionListener of wat voor Listener dan ook (wat in .NET dus delegates zijn). De Runnable is ook een interface die in deze categorie past.

Dit zijn allemaal interfaces met vaak maar 1 methode. Methoden (bijvoorbeeld een algoritme) krijgen een object mee wat deze interface implementeert en gebruikt deze in feite op dezelfde manier als een delegate. Ik gebruik ze ook zelf erg veel in mijn eigen ontwerpen en dat functioneert allemaal uitstekend.

Interfaces en delegates zijn natuurlijk niet equivalent maar het wordt erg lastig om een toepassingen van functie-pointers/delegates te verzinnen wat niet met behulp van een interface kan worden opgelost.

[whoami]

Op donderdag 16 mei 2002 21:19 schreef mbravenboer het volgende:
Het verband tussen interfaces en delegates? Nou ja, dat lijkt mij eigenlijk wel duidelijk . In Java worden heel veel interfaces gebruikt voor zaken waarbij je in talen met delegates zou kunnen werken. Ik noemde als voorbeeld de Comparator, maar een ander voorbeeld is de ActionListener of wat voor Listener dan ook (wat in .NET dus delegates zijn). De Runnable is ook een interface die in deze categorie past.

Ja, idd. In Java werkt het event-model met Listeners en in .NET worden delegates gebruikt. Nu, mijn mening is wel dat ik dat model met die delegates veel mooier en ook wel duidelijker vind. Maar da's natuurlijk een kwestie van smaak en gewoonte.
Maar, de achterliggende gedachte is toch wel anders en daarom vind ik het een beetje raar dat je een vergelijking maakt tussen delegates en interfaces.

[mbravenboer]

whoami: Maar, de achterliggende gedachte is toch wel anders en daarom vind ik het een beetje raar dat je een vergelijking maakt tussen delegates en interfaces.

Nou ja, ik vind de overeenkomst toch echt erg treffend. Allereerst worden ze zoals je zelf al aangeeft voor dezelfde doeleinden gebruikt. Interfaces zijn uiteraard vooral bedoeld om capaciteiten van objecten te beschrijven en deze kan je in een functionele-stijl van object-georienteerd programmeren ook heel goed gebruiken om een bepaald onderdeel van algoritme te scheiden van een implementatie (denk aan de comparator).

Delegate specificaties in .NET komen exact overeen met een interface specificatie in Java met maar 1 fuctie. Een 'instantie' van een delegatie is in .NET een simpele methode, in Java is dit een aparte klasse die de interface implementeert. Als je een functionele stijl van programmeren kent en dus aanvoelt wat de gedachte is van functies via interfaces, zijn er echt maar weinig verschillen te ontdekken, behalve de overhead van de klasse.

Als je trouwens naar de SOAP messages gaat kijken die gebruikt worden in .NET Remoting zal je merken dat er intern zelfs zo tegen delegates wordt aangekeken. De mapping is te vergelijken met de properties, die daar ook gewoon mappen naar methoden.

Kortom: het is uiteraard een andere technische realisatie, maar de scheiding tussen specificatie en implementatie en de doeleinden waarvoor je het kunt gebruiken komen toch echt erg veel overeen. "Vreemd" zou ik het leggen van deze relatie dus zeker niet willen noemen .

[.oisyn]

mag ik de heren drukken op het feit dat de titel van de topic "[C++] Newbie vraag: waarom pointers?" is?

[Verwijderd]

code:

"Waarom wil niemand z'n uptime bij laten houden? ....."

waarom wel ??

[whoami]

Op vrijdag 17 mei 2002 00:52 schreef .oisyn het volgende:
mag ik de heren drukken op het feit dat de titel van de topic "[C++] Newbie vraag: waarom pointers?" is?

Ok, maak jij dan eens even een korte recapitulatie om ons terug bij de les te brengen?

[.oisyn]

ik doelde meer op dat door mij vetgedrukte woord, niet zozeer dat het offtopic was