[C++] Generieke functieaanroep

[liquid_ice]

Ik wil een soort vertaal library (voor little / big endian enzo) maken, waarvan een functie van worden aangeroepen met 1 of meerdere variabelen. Om het zo universeel mogelijk te krijgen ben ik eigelijk opzoek naar een generieke functie aanroep.

Ik zou ietrs kunnen doen als

code:

Functie 1:
VertaalInt(int)

Functie 2:
VertaalInt(int, int)

Functie 3:
VertaalInt(int, int, int)

Functie n:
......

Als ik naast ints ook chars, strings, bool, enum's enz...
wil ondersteunen dan worden het oneindig veel functies.
Hoe kan ik mijn functie aanroep op een generieke manier laten gebeuren om zoveel mogelijk flexibiliteit te krijgen?

[Boy]

Ik weet wel ongeveer hoe het werkt...maar met google vind je het ook zo:

http://www.softwareacadem...20Number%20of%20Arguments

nog niet zelf helemaal doorgelezen maar moet zoiets zijn wat je zoekt...

edit: deze misschien duidelijker : http://www.mycplus.com/tutorial.asp?TID=177

[ Voor 32% gewijzigd door Boy op 28-09-2007 11:45 ]

[.oisyn]

Daar heb je niets aan, dan weet je de types namelijk niet.

Wat je kunt doen is gebruik maken van templates, dan hoef je maar N functies te schrijven om N verschillende parameters te ondersteunen.

C++:

template<class T1> void Vertaal(T1 & p1);
template<class T1, class T2> void Vertaal(T1 & p1, T2 & p2);
template<class T1, class T2, class T3> void Vertaal(T1 & p1, T2 & p2, T3 & p3);
// etc

Maar waarom houd je het niet gewoon bij (overloaded) functies met maar 1 parameter? Ik bedoel, je kunt natuurlijk ook gewoon makkelijk vanuit code meerdere keren die functie aanroepen voor verschillende variabelen.

[ Voor 20% gewijzigd door .oisyn op 28-09-2007 11:47 ]

[Boy]

.oisyn schreef op vrijdag 28 september 2007 @ 11:46:
Daar heb je niets aan, dan weet je de types namelijk niet.

Wat je kunt doen is gebruik maken van templates, dan hoef je maar N functies te schrijven om N verschillende parameters te ondersteunen.

C++:

template<class T1> void Vertaal(T1 & p1);
template<class T1, class T2> void Vertaal(T1 & p1, T2 & p2);
template<class T1, class T2, class T3> void Vertaal(T1 & p1, T2 & p2, T3 & p3);
// etc

Maar waarom houd je het niet gewoon bij (overloaded) functies met maar 1 parameter? Ik bedoel, je kunt natuurlijk ook gewoon makkelijk vanuit code meerdere keren die functie aanroepen voor verschillende variabelen.

stel dat je weet dat alle variabelen wel hetzelfde type hebben, kun je dan wel

C++:

template<class T1> void Vertaal(T1 & p1, ...);

doen?

[.oisyn]

Dat kan idd wel, maar het is niet erg typesafe. Niemand waarschuwt jou als je eerste argument een float is en je tweede een std::string oid.

[PiepPiep]

Boy schreef op vrijdag 28 september 2007 @ 11:48:
[...]


stel dat je weet dat alle variabelen wel hetzelfde type hebben, kun je dan wel

C++:

template<class T1> void Vertaal(T1 & p1, ...);

doen?

Alleen weet je op deze manier niet hoeveel variabelen je krijgt.

C++:

template<class T1> void Vertaal(int aantal, T1 & p1, ...);

Zoiets zou het dan worden.

[.oisyn]

Eigenlijk is het gewoon wachten op C++09's variadic templates

C++:

template<class... T> void Vertaal(T... & args);

[liquid_ice]

.oisyn schreef op vrijdag 28 september 2007 @ 11:46:
Wat je kunt doen is gebruik maken van templates, dan hoef je maar N functies te schrijven om N verschillende parameters te ondersteunen.

C++:

template<class T1> void Vertaal(T1 & p1);
template<class T1, class T2> void Vertaal(T1 & p1, T2 & p2);
template<class T1, class T2, class T3> void Vertaal(T1 & p1, T2 & p2, T3 & p3);
// etc

Ok, dus als ik max 10 parameters wil ondersteunen zijn het maar 10 functies, das wel mooi

Maar waarom houd je het niet gewoon bij (overloaded) functies met maar 1 parameter? Ik bedoel, je kunt natuurlijk ook gewoon makkelijk vanuit code meerdere keren die functie aanroepen voor verschillende variabelen.

Intern wilde ik dat doen. Elke variabele laten vertalen door een speciale functie, maar voor de interface liever niet. Het word een aangepaste XDR vertaal class (voor de geintereseerden), waarbij het grote geheel is voor als iemand op een Intel met windows een functie aanroept met een aantal params en de juiste functie moet worden uitgevoerd (met de juiste waarden natuurlijk) op een ander systeem (mogelijk arm, motorola oid) met mogelijk andere besturingssysteem en een ander endian systeem.

.oisyn schreef op vrijdag 28 september 2007 @ 13:01:
Eigenlijk is het gewoon wachten op C++09's variadic templates

C++:

template<class... T> void Vertaal(T... & args);

C++09's variadic??
ken ik niet, wat is dat?

[H!GHGuY]

C++:

template<class T> bool Vertaal(T& arg)
{
  return false; // unknown T
}

bool Vertaal(int& arg)
{
   arg = htonl(arg);
   return true;
}

template<class T> Vertaal(std::vector<T>& args)
{
   for (std::vector<T>::iterator begin=args.begin(), end=args.end(); begin != end; ++begin)
      Vertaal(*begin);
}

Boost heeft macro's die overloads kunnen maken voor 1->n parameters. Of die hier bruikbaar zijn is echter nog de vraag.

[.oisyn]

liquid_ice schreef op vrijdag 28 september 2007 @ 14:17:
C++09's variadic??
ken ik niet, wat is dat?

C++09 is de nieuwe C++ standaard die in 2009 verwacht wordt. "Variadic" staat voor de ... syntax, functies die het gebruiken (zoals printf) heten variadic functies. C++09 krijgt zogenaamde 'variadic templates', waarbij het aantal template argumenten variabel kan zijn. Op die manier kun je dus echte type-safe variadic functies maken, omdat je een object meekrijgt waarop je (tijdens compile-time) de typen en het aantal argumenten op kunt vragen. Zie ook hier.

Een mooie implementatie zou dus zijn:

C++:

void Vertaal(int & i) { i = htonl(i); }
void Vertaal(float & f) { /* etc */ }

template<class T, class... Args>
void Vertaal(T & head, Args&... tail)
{
    Vertaal(head);
    Vertaal(tail...);
}

Maar goed, nog eventjes wachten dus, eerst totdat de standaard is geformuleerd en daarna tot je favo compiler boer 'm geïmplementeerd heeft

[ Voor 19% gewijzigd door .oisyn op 28-09-2007 15:11 ]

[liquid_ice]

alleen jammer dat de opdrachtgever waarschijnlijk niet wil wachten to '09 ergens...
maar voor toekomstige oplossingen is het prachtig

[writser]

Als je niet weet hoeveel argumenten je functie krijgt, waarom gebruik je dan geen std::vector? Of (minder netjes) een pointer naar een array met argumenten? Een functie voor integers bijv:

C++:

int som(std::vector<int> & lijst) {
  std::vector<int>::iterator i;
  int som = 0;
  for (i = lijst.begin(); i != lijst.end(); i++) {
    som += *i;
  }
  return som;
}

Dat is toch veel generieker? Eventueel kun je deze functie met templates zo aanpassen dat hij ook werkt op floats, doubles en al je eigen datatypes. Misschien kun je iets vertellen over de context waarin je deze functie nodig hebt. Ik stel me namelijk zo'n soort code voor:

C++:

int getal0 = 442;
int getal1 = 33;
..
int getal99 = 21;

doeIets(getal0, getal1, getal2, getal3, ....);

Waarbij een lijst of een andere datastructuur een veel logischere oplossing is.

[ Voor 23% gewijzigd door writser op 28-09-2007 17:37 ]

[MSalters]

Gewoon de std::cout truc gebruiken?

C++:

Vertaal << a << b << c;

[liquid_ice]

Dus (als ik het goed begrijp) kan je geen typesafe oplossing maken voor 1 functie met onbekend aantal params(zolang we niet die '09 uitbreiding hebben).
Voor een typesafe oplossing moet je dus templates gebruiken zoals .oisyn in z'n eerste post heeft gemeld.

over de context, zoek maar eens op XDR (eXternal Data Representation) of bezoek http://www.unet.univie.ac...rggd/progcomc/xdr_ovw.htm

@MSalters, geen idee, maar ik verwacht dat dat niet typesafe is.

[Orphix]

liquid_ice schreef op zaterdag 29 september 2007 @ 00:22:
@MSalters, geen idee, maar ik verwacht dat dat niet typesafe is.

Het is operator overloading, en dus typesafe (als je wilt). Daarnaast vind ik dit veruit de meeste elegante oplossing.

[H!GHGuY]

C++:

#define Vertaal(...) do { CVertaal(), __VA_ARGS__; } while (false);

class CVertaal()
{
   public:
   CVertaal() {}
   CVertaal& operator,(int& a) { a = ntohl(a); return *this}
   CVertaal& operator,(float& a) {...; return *this; }
}

Of het proper is, is een andere vraag natuurlijk, maar creatief is het wel

Als je echt functies wil kun je beter voor templates en vector's gaan voor meerdere argumenten, ofwel zoals MSAlters aangeeft operator<< overloaden

[.oisyn]

vararg macro's in C++? Dacht het niet

[Zoijar]

Of iets dat lijkt op deze manier hoe ik het ooit heb geschreven:

Oh, ik begrijp nu pas wat je wilt, je wil types kunnen mixen in 1 functie call. Ik dacht dat alle functies wel dezelfde types wilden. Je wilt een soort php.

In plaats van dit alles zelf uit te vinden kan je ook even de Boost reference door lezen.

(ik heb hier best lang niet gepost eigenlijk... ook een tijd niet met C++ bezig gehouden. Ik heb denk ik al zeker een jaar niet in de standaard gekeken )

Anyway, ja gewoon wat michiel zegt lijkt me, de stream libraries zijn niet voor niets zo geschreven. Die zitten behoorlijk goed in elkaar. (standard c++ iostreams and locales, langer&kreft) Eerlijk gezegd denk ik dat je je hele "vertaal" procedure kan implementeren op de bestaande streams.

[ Voor 101% gewijzigd door Zoijar op 30-09-2007 12:02 ]

[H!GHGuY]

.oisyn schreef op zaterdag 29 september 2007 @ 23:23:
vararg macro's in C++? Dacht het niet

gcc en visual studio ondersteunen het, dus waarom niet

[farlane]

H!GHGuY schreef op zondag 30 september 2007 @ 12:20:
[...]


gcc en visual studio ondersteunen het, dus waarom niet

Vanaf Visual Studio 2005 volgens mij pas

[H!GHGuY]

farlane schreef op zondag 30 september 2007 @ 13:27:
[...]


Vanaf Visual Studio 2005 volgens mij pas

Dat is waarschijnlijk ook wel weer waar.
Anderzijds is het schrijven van die extra macro's nu ook niet het allergrootste probleem als er geen ondersteuning is voor variadic macro's

[ Voor 7% gewijzigd door H!GHGuY op 30-09-2007 17:03 ]

[liquid_ice]

De eerste manier van .Oisyn spreekt me toch wel echt aan.

Ik heb ooit wat gelezen over RTTI (Real Time Type Identyfication), maar zijn er nog andere manieren om de typen te achterhalen als je een maal in de aangeroepen functie zit?

Zulke templates, is daar nog een speciale manier voor binnen UML om dat weer te geven?
(PS : Of moet ik dit ff in een nieuw topic openen)

[ Voor 114% gewijzigd door liquid_ice op 01-10-2007 12:58 ]

[.oisyn]

liquid_ice schreef op maandag 01 oktober 2007 @ 09:53:
Ik heb ooit wat gelezen over RTTI (Real Time Type Identyfication), maar zijn er nog andere manieren om de typen te chaterhalen als je een maal in de aangeroepen functie zit?

Hoe bedoel je, "andere" manieren? RTTI werkt vrij simpel: typeid(myVar) == typeid(int) -> myVar is een int. Maar in jouw usecase is dat wellicht niet handig, het handigst is als je gewoon overloads van de Vertaal() functie maakt van 1 parameter voor elk type dat je wilt kunnen converteren. In die template functie roep je vervolgens voor elke parameter die enkele functie aan. De compiler doet de rest

C++:

void Vertaal(int & i) { /* converteer i */ }
void Vertaal(float & f) { /* converteer f */ }
// etc

template<class T1, class T2> void Vertaal(T1 & p1, T2 & p2)
{
    Vertaal(p1);
    Vertaal(p2);
}

template<class T1, class T2, class T3> void Vertaal(T1 & p1, T2 & p2, T3 & p3)
{
    Vertaal(p1);
    Vertaal(p2); 
    Vertaal(p3);
}

// etc

[ Voor 22% gewijzigd door .oisyn op 01-10-2007 12:13 ]

[Zoijar]

run-time type indentification; dat het "real-time" gaat is maar te hopen Maar dat heb je niet nodig hier als je calls statisch zijn. Ik vind de stream oplossing netter imo. Geeft ook duidelijker het model weer: als ik 1 functie aanroep met 10 argumenten verwacht ik dat het parallel gaat oid. Als ik 10 elementen een voor een stream weet ik waar ik aan toe ben.

[liquid_ice]

@Zoijar, sorry het moet ook run time zijn, foutje van mijn kant.