[c++] Eén functie met 2 functie-aanroepen?

[r0bert]

Kan ik in c++ een functie 2 functiehandles geven? vb:

C++:

bool fOpenFile(ofstream& iFile, char cFilename[], bool bIsBinary)
bool fOpenFile(ifstream& iFile, char cFilename[], bool bIsBinary)
{
    if (bIsBinary)
        iFile.open(cFilename, ios::binary);

    else
        iFile.open(cFilename);
}

dus dat ik deze functie zowel met een ofstream als met een ifstream aan kan roepen (en nee, gaat me er niet om dat het ook met fstream kan )

[Sendy]

Ik ben niet zo'n held in C++, maar je kan natuurlijk die ofstream& (adres) gewoon casten naar een void*, deze doorgeven en dan in deze functie weer casten naar het juiste type.

Dit lijkt me wel erg goor

edit:

Of je maakt een union van de twee type streams, en geeft zo'n type door. Ook niet heel lekker, je moet dit eigenlijk niet willen. Waarom wil je het zo, en niet gewoon twee functies?

[ Voor 34% gewijzigd door Sendy op 03-11-2004 20:31 ]

[Creepy]

C++ kent method overloading. Dus als jij 2 methods met dezelfde naam maakt waarvan de parameters verschillend zijn dan kan dat.

Zoek je het de volgende keer zelf op in je C++ boek?

[r0bert]

Ja dat kan natuurlijk!............... Wat bedoel je? Is pas mijn eerste blok c++

@Creepy:
Ja, maar zoals ik het nu heb is dat dus niet goed ? *gaat zoeken op function overloading* (ennuh, internet is mijn c++ boek en daar kon ik het niet vinden )

[ Voor 52% gewijzigd door r0bert op 03-11-2004 20:32 ]

[Eskimootje]

Als dit beide specialisatie's zijn van een dezelfde klasse en je daarvan dezelfde functie aanroept kan het anders volgens mij niet netjes iig.

Moet je wel een type aanvragen van de generieke klasse, en niet de specialisatie's.

[ Voor 25% gewijzigd door Eskimootje op 03-11-2004 20:31 ]

[Erkens]

zoek eens op templates

[NMe]

r0bert schreef op 03 november 2004 @ 20:30:
Ja dat kan natuurlijk!............... Wat bedoel je? Is pas mijn eerste blok c++

2 functies uitschrijven waarvan alleen de parameters verschillen.

[Sendy]

Ik zie in de (voorbeeld) code helemaal geen klassen (dus denk ik dat dit inderdaad het eerste hoofdstuk is.)

[r0bert]

Je bedoelt gewoon functie kopieeren/plakken met andere aanroep? Dat wou ik juist proberen te vermijden, maar volgens mij is c++ niet zo dynamisch om dat makkelijk op te lossen Zie iig al heel wat termen voorbij vliegen waar ik vraagtekens bij moet zetten, omdat ik nog maar net met c++ begonnen ben

[Sendy]

Maar nee, je kan niet op deze manier een functie maken. Je kan in C(++) wel functies maken met een variabel aantal parameters, maar niet twee aanroepen voor dezelfde functie. Met methods op verschillende objects kan je dit wel.

edit:

But correct me if i'm wrong. Maar corrigeer me als ik het fout heb.

[ Voor 21% gewijzigd door Sendy op 03-11-2004 20:57 ]

[Erkens]

r0bert schreef op 03 november 2004 @ 20:35:
Je bedoelt gewoon functie kopieeren/plakken met andere aanroep? Dat wou ik juist proberen te vermijden, maar volgens mij is c++ niet zo dynamisch om dat makkelijk op te lossen Zie iig al heel wat termen voorbij vliegen waar ik vraagtekens bij moet zetten, omdat ik nog maar net met c++ begonnen ben

Ik heb ook zojuist 1 blok c++ gehad (net tentamen gedaan) en daar hebben wij gewoon alles gehad wat ik hier in dit topic lees aan termen

[ Voor 74% gewijzigd door Erkens op 03-11-2004 20:43 ]

[r0bert]

@Erkens:
Oh dan doe je OF WO OF je zit op een betere school

@Rest:
Heeft er iemand een voorbeeld van een oplossing of waar ik een voorbeeld kan vinden? Want ik verdrink in de zoekresultaten..

[Erkens]

Sendy schreef op 03 november 2004 @ 20:40:
Maar nee, je kan niet op deze manier een functie maken. Je kan in C(++) wel functies maken met een variabel aantal parameters, maar niet twee aanroepen voor dezelfde functie. Met methods op verschillende objects kan je dit wel.

?

C++:

template<typename T>
void functie(T objectje){}

r0bert schreef op 03 november 2004 @ 20:42:
@Erkens:
Oh dan doe je OF WO OF je zit op een betere school

HBO (Hogeschool v. Amsterdam)

[NMe]

r0bert schreef op 03 november 2004 @ 20:42:
@Erkens:
Oh dan doe je OF WO OF je zit op een betere school

OF jouw school zuigt.

r0bert schreef op 03 november 2004 @ 20:42:
@Rest:
Heeft er iemand een voorbeeld van een oplossing of waar ik een voorbeeld kan vinden? Want ik verdrink in de zoekresultaten..

Als je je verdiept in die dingen die hier genoemd worden, dan moet je er toch wel uit komen? Begin maar met templates, zoals Erkens al zegt, die zijn bij uitstek geschikt voor iets als dit.

[Sendy]

Erkens >
Oh ja, leuk die templates. Ik heb dat nooit echt begrepen. Wat schrijf je op typenaam trouwens?

[Zoijar]

Dat mag ook class zijn, maar tegenwoordig wordt er geneigd naar typename. Zelf zie ik altijd typename als echt de naam van een type (int float double etc) dat het dus zuiver om het type gaat. En class voor een echte class parameter, zoals bv een Operator class die statisch kan optellen oid. Maar het mag allebei hier.

[Sendy]

Ik mis teveel achtergrond (en ik heb ook niet veel zin om templates te gaan leren ), maar wat geef je in zo'n template statement aan? Er kan maar 1 type in staan?

edit:

Oh, ik begrijp het al: het is letterlijk class of typename. Zo'n template lijkt me eigenlijk een soort union?

[ Voor 31% gewijzigd door Sendy op 03-11-2004 21:09 ]

[Zoijar]

Het is een soort van generiek type, maar dan iets krachtiger. Teveel werk om uit te leggen hier als je er nog nooit iets mee gedaan hebt. hier staat een soort van intro.

[Creepy]

NMe84 schreef op 03 november 2004 @ 20:44:
[...]

Als je je verdiept in die dingen die hier genoemd worden, dan moet je er toch wel uit komen? Begin maar met templates, zoals Erkens al zegt, die zijn bij uitstek geschikt voor iets als dit.

Ik zou beginnen met method overloading. Stukken simpeler dan templates

[eghie]

Method overloading is hier idd het meest geschikt.

Dus gewoon zo:

C++:

bool fOpenFile(ofstream& iFile, char cFilename[], bool bIsBinary) 
{
    ........
}

bool fOpenFile(ifstream& iFile, char cFilename[], bool bIsBinary) 
{ 
    ........
}

[MSalters]

Misschien is het handig om erbij te vertellen waarom overloading beter is?

Met overloading geef je precies aan welke twee types er toegestaan zijn.

Met templates kun je alleen aangeven dat de eerste parameter een & moet zijn, maar dat zou ook een window& kunnen zijn. Goed, op het moment dat de compiler die window& verderop invult komt die er wel achter dat window.open( ) geen ios::binary snapt, maar de foutmelding is dan best verwarrend.

Met overloading is de mededeling typisch duidelijker, iets van
"none of the 2 overloads of fOpenFile matched argument 1 window&.
Considered bool fOpenFile(ifstream& ...), bool fOpenFile(ofstream& ... )"

[ Voor 4% gewijzigd door MSalters op 03-11-2004 22:36 ]

[MSalters]

Sendy schreef op 03 november 2004 @ 20:28:
Ik ben niet zo'n held in C++, maar je kan natuurlijk die ofstream& (adres) gewoon casten naar een void*, deze doorgeven en dan in deze functie weer casten naar het juiste type.

Dit lijkt me wel erg goor

Waarom zo vies? ifstream en ofstream hebben een gemeenschappelijke base class, dus je kunt daar naar toe casten (gebeurt zelfs automatisch). de TS heeft daar niets aan, omdat ifstream::open en ofstream::open twee verschillende functies zijn.

[Erkens]

Creepy schreef op 03 november 2004 @ 22:15:
[...]

Ik zou beginnen met method overloading. Stukken simpeler dan templates

true, maar wat hij wil is dat hij niet 2x dezelfde code hoeft te schrijven, hoe wil je dat dan doen

[Zoijar]

C++:

#define CompiletimeAssert(expr, msg) typedef char ERROR_##msg##[1][(expr)]

template <typename T>
void openStream(T& s) {
   CompiletimeAssert(false, cannot_open_non_stream_type);
}

template <>
void openStream<std::iftream>(std::iftream& s) {
   s.open();
}

template <>
void openStream<std::ofstream>(std::ofstream& s) {
   s.open();
}

Prachtige foutmelding

[ Voor 10% gewijzigd door Zoijar op 03-11-2004 23:37 ]

[MSalters]

En verschrikkelijk fout natuurlijk.

C++:

class MyStream : public ifstream { ... };
MyStream ms;
openStream( ms );

fstream fs;
openStrealm (fs);

[Zoijar]

MSalters schreef op 04 november 2004 @ 09:53:
En verschrikkelijk fout natuurlijk.

Ja, klopt. Het was maar een voorbeeld, je kan dit verder doorvoeren, en dan kan je 1 functie template schrijven waar je een statische check doet of het gegeven type een inheritance relatie heeft met een van de twee, of gelijk is, of dat er een conversion bestaat. Loki heeft hier bv SuperSubClass voor en Conversion (in typemanip.h)

[curry684]

r0bert schreef op 03 november 2004 @ 20:20:
Kan ik in c++ een functie 2 functiehandles geven? vb:

C++:

bool fOpenFile(ofstream& iFile, char cFilename[], bool bIsBinary)
bool fOpenFile(ifstream& iFile, char cFilename[], bool bIsBinary)
{
    if (bIsBinary)
        iFile.open(cFilename, ios::binary);

    else
        iFile.open(cFilename);
}

dus dat ik deze functie zowel met een ofstream als met een ifstream aan kan roepen (en nee, gaat me er niet om dat het ook met fstream kan )

C++:

template <typename T>
bool fOpenFile(T& iFile, char cFilename[], bool bIsBinary)
{
    if (bIsBinary)
        iFile.open(cFilename, ios::binary);

    else
        iFile.open(cFilename);
}

En klaar is Klara, nu kun je deze functie aanroepen met iedere class die een open() heeft met de correcte parameters (templates worden compiletime verwerkt dus je krijgt een error als je er een fout datatype zoals een int instopt).

[H!GHGuY]

maken jullie dit niet gewoon te moeilijk???

de TS zegt zelf dat ie nog maar in het begin is van het leren van C++... ik heb zelf (op school en door zelfstudie) al redelijk wat geleerd, maar templates bvb heb'k nog niet tegengekomen/nodig gehad...

de 2 simpelste, en properste oplossingen zijn volgens mij nog steeds:
1) function overloading
2) base class fstream gebruiken

[curry684]

HIGHGuY schreef op 04 november 2004 @ 11:20:
maken jullie dit niet gewoon te moeilijk???

de TS zegt zelf dat ie nog maar in het begin is van het leren van C++... ik heb zelf (op school en door zelfstudie) al redelijk wat geleerd, maar templates bvb heb'k nog niet tegengekomen/nodig gehad...

de 2 simpelste, en properste oplossingen zijn volgens mij nog steeds:
1) function overloading

Vind ik overigens ook, ware het niet dat ik uberhaupt het nut niet zie van de functie uit de topicstart (hij rewrite enkel wat semantics).

2) base class fstream gebruiken

fstream is geen common ancestor.

[Zoijar]

fstream is geen base class van ifstream of ofstream, die zijn subs van resp. istream en ostream, die als gezamelijke base class ios hebben die geen open() call ondersteunt. Je kan wel een fstream gebruiken, die is afgeleid van iostream, die multiple inheritance heeft vanaf zowel istream als ostream.

Met function overloading moet je dezelfde code twee keer schrijven, dat is niet echt netjes. Je gaat er later een veranderen, en vergeet de andere. Je moet dus een 'common' initialisatie functie maken, maar het probleem daar is dat het niet kan omdat het twee verschillende types zijn. Dus templates om een ifs en ofs te openen. Maar dan heb je het probleem, wat als iemand een socket meegeeft; die gaat dan vrolijk address reolution doen op de filename. Niet echt wenselijk. Dus moet je een mooie foutmelding zien te verkrijgen bij iets anders dan ifs of ofs. Maar dan kunnen afgeleiden klasses weer niet, zoals bv een tcpstream oid. Daar kan je dan weer omheen werken met statische conversion en inheritance tests. Al met al kan je denk ik beter gewoon twee functies schrijven.

[H!GHGuY]

curry684 schreef op 04 november 2004 @ 11:24:
[...]

Vind ik overigens ook, ware het niet dat ik uberhaupt het nut niet zie van de functie uit de topicstart (hij rewrite enkel wat semantics).

[...]

fstream is geen common ancestor.

oops, ik ging even af op:

r0bert schreef op 03 november 2004 @ 20:20:dus dat ik deze functie zowel met een ofstream als met een ifstream aan kan roepen (en nee, gaat me er niet om dat het ook met fstream kan )

[Zoijar]

Zoiets:

C++:

#define CompiletimeAssert(expr, msg) typedef char ERROR_##msg##[1][(expr)]

template <typename T1, typename T2>
class Conversion {
    typedef char Small;
    class Big {char dummy[2];};

    static Small Test(T2);
    static Big Test(...);
    static T1 Make();

public:
    enum {exists = sizeof(Test(Make())) == sizeof(Small),
          sameType = false
    };
};

template <typename T>
class Conversion<T, T> {
public:
    enum {exists = true, sameType = true};
};

template <typename T>
bool fOpenFile(T& iFile, char cFilename[], bool bIsBinary) { 
    CompiletimeAssert((Conversion<T, std::ifstream>::exists || Conversion<T, std::ofstream>::exists), Cannot_open_non_stream_type);
    if (bIsBinary) 
        iFile.open(cFilename, ios::binary); 

    else 
        iFile.open(cFilename); 
}

Beetje omslachtig. (Heb het overigens niet gecompiled, kunnen foutjes inzitten.)

[.oisyn]

Zoijar schreef op 03 november 2004 @ 23:37:

C++:

#define CompiletimeAssert(expr, msg) typedef char ERROR_##msg##[1][(expr)]

template <typename T>
void openStream(T& s) {
   CompiletimeAssert(false, cannot_open_non_stream_type);
}

template <>
void openStream<std::iftream>(std::iftream& s) {
   s.open();
}

template <>
void openStream<std::ofstream>(std::ofstream& s) {
   s.open();
}

Prachtige foutmelding

dan kun je net zo goed overloaden

[Zoijar]

.oisyn schreef op 04 november 2004 @ 11:53:
dan kun je net zo goed overloaden

Jajajaja, ik maakte een fout, mea culpa lol. Ik heb het al recht gezet boven, dat is wat ik eigenlijk bedoelde...

[curry684]

Volgens mij blijf ik dit simpelweg de charmantste vinden:

C++:

  inline bool fOpenFile(ifstream& iFile, char cFilename[], bool bIsBinary)
  { 
  return internalOpenFile(iFile, cFilename, bIsBinary);
  }
  
  inline bool fOpenFile(ofstream& iFile, char cFilename[], bool bIsBinary)
  { 
  return internalOpenFile(iFile, cFilename, bIsBinary);
  }

  template <typename T>
  bool internalOpenFile(T& iFile, char cFilename[], bool bIsBinary)
  { 
    if (bIsBinary)
        iFile.open(cFilename, ios::binary);

    else
        iFile.open(cFilename);
  }

En dan gewoon de internal functie private maken in een class, of niet extern maken als ie global is

[Zoijar]

Ja, dat is misschien wel beter. In ieder geval snap je zelf dan de rare foutmeldingen, en hoef je daar een geberuiker niet mee op te schepen.

[MSalters]

curry684 schreef op 04 november 2004 @ 11:16:
[...]

C++:

template <typename T>
bool fOpenFile(T& iFile, char cFilename[], bool bIsBinary)
{
    if (bIsBinary)
        iFile.open(cFilename, ios::binary);

    else
        iFile.open(cFilename);
}

En klaar is Klara, nu kun je deze functie aanroepen met iedere class die een open() heeft met de correcte parameters (templates worden compiletime verwerkt dus je krijgt een error als je er een fout datatype zoals een int instopt).

BTDT

C++:

class MsgBox {
  static void open( string const& Title, window* parent = 0 );
  ...
};
MsgBox msg;
ifstream if;
fOpenFile( msgbox, "filename.txt", false );
msgbox.open("Filename.txt is now open", gAppWindow); 

Leuke foutmelding geeft dat.

[curry684]

Jaja dan hadden die ballen gehakt van de C++ Standard Committee maar gewoon goeie interface-definities moeten opzetten voor de standard classes, dan had je wel 100% typesafe puur op een interface kunnen werken

[MSalters]

Die genieen houden gweoon geen rekening met wat vage windowshippies die het verschil tussen input en output niet kennen. Bij het openen van een inputfile hoef je logischerwijs niet na te denken over het truncaten van een eventueel bestaande file; bij het openen van een outputfile wel etcetera. Logischerwijs zijn er dus twee verschillende open( ) interfaces.

nofi uiteraard

[.oisyn]

MSalters schreef op 04 november 2004 @ 13:06:
[...]

BTDT

C++:

class MsgBox {
  static void open( string const& Title, window* parent = 0 );
  ...
};
MsgBox msg;
ifstream if;
fOpenFile( msgbox, "filename.txt", false );
msgbox.open("Filename.txt is now open", gAppWindow); 

Leuke foutmelding geeft dat.

Idd, namelijk iets als "Expected: identifier" op regel 6

[curry684]

MSalters schreef op 04 november 2004 @ 13:54:
Die genieen houden gweoon geen rekening met wat vage windowshippies die het verschil tussen input en output niet kennen. Bij het openen van een inputfile hoef je logischerwijs niet na te denken over het truncaten van een eventueel bestaande file; bij het openen van een outputfile wel etcetera. Logischerwijs zijn er dus twee verschillende open( ) interfaces.

nofi uiteraard

Tsk en wat had ze tegengehouden om een IDontCareJustOpenTheDamnThing interface te definieren?

[riezebosch]

Ehmm... Hoe groot is de kans dat je (uiteindelijk) in een fuctie hetzelfde wilt doen met een ifstream als met een ofstream

[MSalters]

curry684 schreef op 04 november 2004 @ 14:58:
[...]

Tsk en wat had ze tegengehouden om een IDontCareJustOpenTheDamnThing interface te definieren?

Ik denk stijl, we hebben geen hongaarse notatie of CamelCaps.

we_dont_care_just_open_the_damn_thing is misschien wel een goed idee, vanavond even een voorstel draften