[C/C++] functie met variable argumenten lijst?

[Verwijderd]

zoals de titel het al zegt: hoe maak ik een functie met een variable argumenten lijst?

ik heb nog geen byte source-code geschreven voor wat ik van plan ben maar: hoe maak ik een functie in C++ die bijvoorbeeld tussen de 2 tot oneindig aantal argumenten kan accepteren? ik ben zeer bekend met PHP waar bijvoorbeeld de functie 'call_user_method' een lijst met argument kan doorgeven aan de functie die wordt ge-called of bijvoorbeeld isset() welke meerdere variable in 1 call kan checken.

volgens het boek wat ik hier heb is de enige oplossing om bijvoorbeeld 32 functie's te declareeren en door middel van functie overloading dit te bereiken maar ik vroeg me af of er een andere manier is om dit te doen want 32 bijna identieke functie's alleen met 1 argument meer lijkt me nou ook niet positief.

dan nog een ander vraagje, ik ben aan het overstappen van PHP naar C++. PHP ken ik zeer goed en in C++ voel ik me dan ook niet als een vis op het droge, eerder een amphibie op het droge. ik heb nu het boek 'C++ in 10 minuten'. een zeer goed boek voor beginners en overstapper's maar nu ik die uit heb wil wel eens een stapje hoger en zit ik te twijfelen tussen deze 3 boeken:

C++ in 24 dagen door Jesse Liberty.
eigenlijk het vervolg, dezelfde auteur dus dezelfde stijl waarschijnlijk wat het voor mij makkelijker lijkt te zijn aangezien ik zijn stijl van uitleggen nu wat gewend ben. een logisch vervolg?

C++ zonder stress door O. Bohn
ik wat gemixde reviews gezien van dit boek. de 1 zegt wel dat het verder gaat dan C++ in 10 minuten maar de andere weer zegt dat het alleen bij de basis priciepes blijft die ik nu wel zo'n beetje ken.

De programmeertaal C++ door Bjarne Stroustrup
van wat ik begrijp is dit zegmaar de 'bijbel' op het gebied van C++. pittige stof geschreven door de geestelijk vader van C++. is dit boek een beter vervolg of zou het nog wat te hoog gegrepen zijn?

welke boek zouden jullie aanbevelen? en is de 'bijbel' echt een must voor elke C++ programmeur?
ik neig dus wat naar 'C++ in 24 dagen' gevolgd door 'De programmeertaal C++' of overlapt dat mekaar?

[Jaap-Jan]

cstdarg includen en dan met '...' aangeven dat de functie een variabel aantal argumenten heeft. Zie: http://www.cplusplus.com/reference/clibrary/cstdarg/. En function overloading is ook een manier om dat te doen, maar niet erg efficient, inderdaad .

Over de boeken kan ik niet zoveel zeggen. Ik heb zelf op school 'C++ from the beginning' van Jan Skansholm gebruikt, maar die vond ik niet geweldig. 'Aan de slag met C++' van Gertjan Laan heb ik ook. Dat boek is wat makkelijker te begrijpen, maar gaat wel redelijk in op een aantal C++ paradigma's (streams, classes, pointers en references). Maar ik ken het boek wat je gelezen hebt niet, maar het klinkt nogal basic. Ik kan dus zelf eigenlijk geen boek aanbevelen.

[grizzlybear]

Function overloading niet efficient? Waarom niet dan? Het nadeel aan een cstdarg functie is dat hij niet type safe is. Dat is PHP zowiezo niet, dus voor de TS misschien superfijn, maar als je echt C++ wilt leren en gebruiken, dan zou ik zeker voor de functie overloading gaan. De functies declareren als template functies en je kunt alles wat je wilt. Type safe. De compiler zorgt ervoor dat alles juist superefficient gebeurd. Hij beschermt je ook tegen typfouten en andere domme dingen.

C++:

template<typename T1> bool Bla(T1 const &Arg1)
{
}

template<typename T1, typename T2> bool Bla(T1 const &Arg1, T2 const &Arg2)
{
}

Let op, omdat het hier om templates gaat, moet je dit wel in de header van je class zetten.

[Jaap-Jan]

grizzlybear schreef op vrijdag 15 juni 2007 @ 07:02:
Function overloading niet efficient? Waarom niet dan? Het nadeel aan een cstdarg functie is dat hij niet type safe is. Dat is PHP zowiezo niet, dus voor de TS misschien superfijn, maar als je echt C++ wilt leren en gebruiken, dan zou ik zeker voor de functie overloading gaan. De functies declareren als template functies en je kunt alles wat je wilt. Type safe. De compiler zorgt ervoor dat alles juist superefficient gebeurd. Hij beschermt je ook tegen typfouten en andere domme dingen.

C++:

template<typename T1> bool Bla(T1 const &Arg1)
{
}

template<typename T1, typename T2> bool Bla(T1 const &Arg1, T2 const &Arg2)
{
}

Let op, omdat het hier om templates gaat, moet je dit wel in de header van je class zetten.

Niet efficient voor de devver in de ze van 32x dezelfde functie moeten overtypen met als enig verschil een extra parameter .

Maare... Templates functies zijn niet hetzelfde als function overloading. Maar ik neem aan dat je dat ook wel weet .

Als TS ook aangeeft wat 'ie eigenlijk wil bereiken. Wellicht dat er dan een oplossing mogelijk is zonder varargs of function overloading. Templates kunnen misschien wel een oplossing zijn, maar misschien heb je gewoon een andere manier van denken nodig .

[MTWZZ]

Overigens is het voor bijvoorbeeld een logging framework ideaal om functies met variabelen te hebben ala printf en consorten.

[simon]

vector of class met settings/data meegeven?

[ Voor 45% gewijzigd door simon op 15-06-2007 08:26 ]

[riezebosch]

Misschien dat default arguments een idee is?

edit:
Betere url gevonden.

[ Voor 54% gewijzigd door riezebosch op 15-06-2007 09:07 ]

[Verwijderd]

Gewoon een variabele argument list gebruiken;

C++:

void printf(char *text, ...){
    va_list ap;
    va_start(ap, text);
    char *tp = text;
    while( *tp != '\0' ){
        if( *tp == '%' ){
            *tp++;
            unsigned long temp = va_arg(ap, unsigned long);
            switch(*tp){
            case 'd':
                printInt(temp);
                break;
            case 'x':
                printhex(temp);
                break;
            }
        }
        else {
            putch(*tp);
        }
        *tp++;
    }
    va_end(ap);
}

Een simpele implementatie van printf. Ik hoop dat je er zo uitkomt. Anders ff googlen op "variable argument list"

[.oisyn]

Verwijderd schreef op vrijdag 15 juni 2007 @ 06:10:
zoals de titel het al zegt: hoe maak ik een functie met een variable argumenten lijst?

ik heb nog geen byte source-code geschreven voor wat ik van plan ben maar: hoe maak ik een functie in C++ die bijvoorbeeld tussen de 2 tot oneindig aantal argumenten kan accepteren? ik ben zeer bekend met PHP waar bijvoorbeeld de functie 'call_user_method' een lijst met argument kan doorgeven aan de functie die wordt ge-called of bijvoorbeeld isset() welke meerdere variable in 1 call kan checken.

Wat voor parameters verwacht je? Allemaal dezelfde types, of allemaal verschillende? Primitieven (int, float, etc.) of ook user-defined types? Er zijn meerdere methodes, maar welke het beste is hangt af van het gebruik.

dan nog een ander vraagje, ik ben aan het overstappen van PHP naar C++. PHP ken ik zeer goed en in C++ voel ik me dan ook niet als een vis op het droge, eerder een amphibie op het droge.

Lol. No offense, maar deze uitspraak geeft eigenlijk al aan hoe onbekend je nog met C++ bent . Het feit dat de syntax van PHP en C++ op elkaar lijkt, en dat PHP wat functies geleend heeft van C, wil nog niet zeggen dat je nu een aardig idee hebt van hoe C++ in elkaar zit .

De programmeertaal C++ door Bjarne Stroustrup
van wat ik begrijp is dit zegmaar de 'bijbel' op het gebied van C++. pittige stof geschreven door de geestelijk vader van C++. is dit boek een beter vervolg of zou het nog wat te hoog gegrepen zijn?

Eigenlijk hoort dit meer in [Alg] Centraal boekentopic - part II
Dit boek is meer een reference dan iets om uit te leren. Ik zou 'm dus niet aanraden voor iemand die net met C++ aan de slag gaat. Als je er echter aardig in thuis bent dan is het een goed boek om bepaalde quirks in op te zoeken

[Verwijderd]

wat ik eigenlijk wil bereiken is de funtie's die bij PHP build-in zijn op C++ her-implementeren zodat je dus de functionaliteit van PHP combineert met de voordelen van C++. daarnaast leek het mij ook wel een goede manier om de taal te leren en ik heb de tijd dus ik kan me er ook echt in gaan verdiepen.

stap 2 zou dan zijn om iets van een converter te bouwen, in PHP waarschijnlijk met de tokens extensie om al mijn bestaande PHP code makkelijk om te zetten naar C++. veel is al geschreven op hoogwaardig nivo, dus ik vermijd type-juggelign en andere moeilijk portable code. het zou toch mooi zijn als ik veel van de code die ik de afgelopen jaren in PHP heb geschreven en waar ik ook mee bekend ben, ken de functie namen en return type's enzo van die al die klassen en methode, gewoon mee zou kunnen nemen. veel is al CLI spul en dus meer abstract en absoluut niet webbased ofzo.

het probleem van variable argumenten is ook maar bij een handje vol van die PHP functie's te vinden. als je de definitie lijst bekijkt op php.net zie je dat ook zend dit zo veel als mogelijk probeert te vermijden of om te zetten in een language struct i.p.v een functie. vanaf PHP 4.10 zijn die functie's bijna uitgestorven of zodanig veranderd dat ze depricated zijn.

eigenlijk zou het nog makkelijker zijn om mijn code gewoon te herschijven op die punten en gewoon een isset op te breken in meerdere functie call's of call_user_method vervangen voor call_user_method_array bijvoorbeeld. maar omdat ik mijn her-implementatie mischien nog wel een ga releasen onder een open-source licentie (geen GPL zodat alleen wijzigingen aan de implementatie zelf moeten worden vrijgegeven niet de ge-compileerder werken ermee, iets zoals wine lib bijvoorbeeld) is het wel zo goed om dus zo minmogelijk afhankelijk te zijn of zoveel mogelijk te abstracten, zoals PHP nu al doet tussen Windows build en Linux builds bijvoorbeeld.

is die cstdarg.h eigenlijk ook onderdeel van de C++ STL? mijn implementatie wordt bijna zeker namelijk C++ en zal voornamelijk met Dev-C++ worden geschreven (MingW compiler). wat zijn jullie ervaringen eigenlijk met Dev-C++? ik heb ook wel VC++ 6.0 in de kast liggen maar ik vind die toch niet zo goed werken. daarnaast begint die ook wel een beetje oud te worden (1998?).

daarnaast is mijn computer aan vervanging toe en ga ik dus tussen nu en mischien 1 of 2 mandjes switchen naar dual-boot (K)Ubuntu + WinXP64. machine is al klaar wacht alleen nog op een 4GB Sandisk Extreme 4 CF welke ik als systeem schijf ga gebruiken. ideen voor een C++ IDE onder Linux?

wat betreft het boek, 'C++ in 10 minuten' is aardig compleet als het gaat om syntax enzo. pointer en references worden uitgelegd. const en virtuele methoden, classes en extending, abstracte datatypen en ook een stukje polymorfisme en template's. wat is dus eigenlijk zoek is een boek die al die basis blokstukken naar het volgende nivo tilt. dus binary search tree's, double linked list of hash table's bijvoorbeeld. of hoe je bepaalde desing pattern's in C++ maakt. ik ken er een aantal uit PHP maar in C++ zijn er heel wat meer mogelijk. zegmaar een boek voor gevorderden maar ook weer niet guru's.

daarnaast wil ik ook wel eens kennis maken met OpenGL, SDL en BOOST. van OpenGL heb ik de originele boeken op het oog, de bekende rode, blauwe, groene, alpha en oranje boeken. begin maar eens met rood of blauw later dit jaar. maar van SDL of BOOST kan ik zo niks vinden. iemand een idee welk boek mij een goede introductie kan geven met SDL of BOOST?

mischien stel ik iets te veel vragen, maar alvast mijn dank voor enige antwoorden.

[.oisyn]

Verwijderd schreef op vrijdag 15 juni 2007 @ 11:26:
wat ik eigenlijk wil bereiken is de funtie's die bij PHP build-in zijn op C++ her-implementeren zodat je dus de functionaliteit van PHP combineert met de voordelen van C++. daarnaast leek het mij ook wel een goede manier om de taal te leren en ik heb de tijd dus ik kan me er ook echt in gaan verdiepen.

Hoewel het een goede oefening kan zijn voor de taal zelf, leer je op die manier niet het paradigima dat aan de taal verbonden is. In PHP heb je geen overloads, daar maak je 1 functie die alle mogelijke aanroepen aankan. In talen als C++ (en Java en C# etc.) is het gebruikelijk om dat met gewone functie-overloads te doen. Functies die verschillende parameters verwachten doen verschillende dingen, het is niet logisch om dat in 1 functie te implementeren die @ runtime ook nog eens de parameters moet gaan controleren of ze van het juiste type zijn etc.. Wat jij wilt doen is gewoon not done in C++.

is die cstdarg.h eigenlijk ook onderdeel van de C++ STL?

De STL staat voor Standard Template Library en was een library van SGI voor templated containers e.d.. Later is deze library toegevoegd aan de standard C++ library, maar mensen gebruiken de STL nog wel om dat gedeelte van de standard library aan te geven. Het heeft dus niets te maken met varags, dat is namelijk gewoon een taal feature, met wat definities om die dingen uit te lezen in de header <cstdarg>. Overigens, zoals al opgemerkt, zijn variadic functies eigenlijk meer een C feature en zijn ze zo type-unsafe als wat. Bovendien kun je niet controleren wat nou het type is van het meegegeven argument - als je een int verwacht en iemand geeft een string dan zal de compiler niet klagen, maar je kan wel raden dat dat niet helemaal goed gaat. Als je echt goede variadic functies wil maken dan kun je beter leunen op een std::vector<boost::any> parameter. Dan kun je mooi bekijken hoeveel parameters er zijn gegeven, van wat voor typen ze zijn, en het voldoet aan alle C++ regels¹

mijn implementatie wordt bijna zeker namelijk C++ en zal voornamelijk met Dev-C++ worden geschreven (MingW compiler). wat zijn jullie ervaringen eigenlijk met Dev-C++? ik heb ook wel VC++ 6.0 in de kast liggen maar ik vind die toch niet zo goed werken. daarnaast begint die ook wel een beetje oud te worden (1998?).

VC 6.0 is crap, die CD moet je doormidden breken en ritueel verbranden. Vziw is Dev-C++ prima, als je echt met windows apps aan de gang wilt is de gratis te downloade Visual C++ 2005 Express wellicht een handigere optie.

---

¹ Desnoods zou je nog zoiets kunnen doen:

C++:

// class die de argumenten houdt
class arg_list_t
{
public:
    size_t size() const { return m_args.size(); }
    const std::vector<boost::any> & args() const { return m_args; }
    const boost::any & operator[](size_t i) { return m_args[i];

    template<class T> arg_list_t & append(const T & t)
    {
        m_args.push_back(boost::any(t));
        return *this;
    }

private:
    std::vector<boost::any> m_args;
};

// wat helper classes en operators voor handig gebruik
template<class T> arg_list_t & operator, (arg_list_t & list, const T & arg)
{
    return list.append(arg);
}


static struct arg_list_start_t { } arg_list_start;
struct arg_list_proxy_t
{
    arg_list_t m_list;
    operator arg_list &() const { return const_cast<arg_list&>(m_list); }
};

template<class T> arg_list_proxy_t operator, (arg_list_start_t, const T & arg)
{
    arg_list_proxy_t proxy;
    proxy.m_list.append(arg);
    return proxy;
}


// functie met variadic argumenten
void myFunc(const arg_list_t & args)
{
    if (args[0].type() != typeid(int))
        throw IllegalArgumentException("myFunc(): first argument should be of type int");
    if (args[0].type() != typeid(float))
        throw IllegalArgumentException("myFunc(): second argument should be of type float");

    std::cout << any_cast<int>(args[0]) << std::endl;
    std::cout << any_cast<float>(args[1]) << std::endl;
}

// aanroep van een dergelijke functie
int main()
{
    myFunc((arg_list_start, 1, 3.4f));  // dubbele haakjes!
}

Je moet hier echter wel mee opletten. Een int is een ander type dan een unsigned int. Je kunt een boost::any die een unsigned int in zich heeft dus ook niet omzetten naar een int, en derhalve moeten de argumenten die je erin stopt ook precies matchen met wat je in de functie verwacht.
Maar ik blijf erbij: gebruik er alsjeblieft gewoon overloads voor

Overigens komt C++09 met variadic templates, die kan zorgen voor de nodige syntactische suiker om dit alles. Maar da's nog een paar jaartjes wachten

[ Voor 39% gewijzigd door .oisyn op 15-06-2007 12:18 ]

[xx77qq]

Verwijderd schreef op vrijdag 15 juni 2007 @ 11:26:
wat ik eigenlijk wil bereiken is de funtie's die bij PHP build-in zijn op C++ her-implementeren zodat je dus de functionaliteit van PHP combineert met de voordelen van C++. daarnaast leek het mij ook wel een goede manier om de taal te leren en ik heb de tijd dus ik kan me er ook echt in gaan verdiepen.

Wat zijn de voordelen van C++? Wellicht loont het de moeite om ook naar C#, Java of Python te kijken (ik ben nl. van mening dat C++ niet meer van deze tijd is). Maar dat was niet je vraag. Zoals iemand anders al opmerkte zullen bepaalde constructies die in PHP heel gewoon en handig zijn dat niet zijn in C++ . Beter is het om je ideeen opnieuw te implementeren, vooral omdat je van een wat hogere taal naar een lagere taal wilt gaan en een aantal eigenschappen niet hebt en 'krom' moet gaan implementeren.

stap 2 zou dan zijn om iets van een converter te bouwen, in PHP waarschijnlijk met de tokens extensie om al mijn bestaande PHP code makkelijk om te zetten naar C++. veel is al geschreven op hoogwaardig nivo, dus ik vermijd type-juggelign en andere moeilijk portable code. het zou toch mooi zijn als ik veel van de code die ik de afgelopen jaren in PHP heb geschreven en waar ik ook mee bekend ben, ken de functie namen en return type's enzo van die al die klassen en methode, gewoon mee zou kunnen nemen. veel is al CLI spul en dus meer abstract en absoluut niet webbased ofzo.

Zelf heb ik in de loop van de jaren ook een aardige library opgebouwd en in mijn geval loonde het niet de moeite om ze te converteren naar een nieuwe taal. Het is meer van, ik ga iets met text/data/file manipulaties doen dan pak ik Python, ik heb iets high-performance nodig zoals een supersnelle blit of linedrawing routine dan pak ik C. En bijna is het een combinatie van die twee.

[quote[
daarnaast is mijn computer aan vervanging toe en ga ik dus tussen nu en mischien 1 of 2 mandjes switchen naar dual-boot (K)Ubuntu + WinXP64. machine is al klaar wacht alleen nog op een 4GB Sandisk Extreme 4 CF welke ik als systeem schijf ga gebruiken. ideen voor een C++ IDE onder Linux?
[/quote]

Eclipse, vi, (x)emacs en nog wat anderen.

Misschien een wat gekleurde reactie van iemand die niet zo gecharmeerd is van C++ (en er misschien ook niet zo goed in is).

[Soultaker]

Verwijderd schreef op vrijdag 15 juni 2007 @ 06:10:
zoals de titel het al zegt: hoe maak ik een functie met een variable argumenten lijst?

ik heb nog geen byte source-code geschreven voor wat ik van plan ben maar: hoe maak ik een functie in C++ die bijvoorbeeld tussen de 2 tot oneindig aantal argumenten kan accepteren? ik ben zeer bekend met PHP waar bijvoorbeeld de functie 'call_user_method' een lijst met argument kan doorgeven aan de functie die wordt ge-called of bijvoorbeeld isset() welke meerdere variable in 1 call kan checken.

Weet je heel zeker dat dit nodig is? Onder PHP is het gebruik van variabele argumenten en het gebruik van call_user_method() ook af te raden in de meeste situaties. In C++ kun je wel variabele argumenten meegeven, maar niet op een typesafe manier, en het programmeert ook niet echt makkelijk. Kun je niet beter een array als argument meegeven?

Of kun je niet een klasse ontwerpen waarmee je variabele argumenten kunt vermijden? Een mooi voorbeeld is bijvoorbeeld de C-functie printf die een variabel aantaal argumenten krijgt; in C++ wordt in plaats daarvan een stream-object gebruikt waar verschillende "argumenten" aan gegeven worden door operator<< te herimplementeren. In plaats van één functiecall met veel argumenten, heb je dan één object waarop voor elk argument een methode aangeroepen wordt. Vaak is het handiger om zo'n OO-constructie te bedenken, dan terug te vallen op paradigma's uit C.

dan nog een ander vraagje, ik ben aan het overstappen van PHP naar C++. PHP ken ik zeer goed en in C++ voel ik me dan ook niet als een vis op het droge, eerder een amphibie op het droge.

De andere boeken ken ik niet, maar het boek van Stroustrup is niet echt geschikt om mee te leren programmeren. Het is vooral interessant om als naslagwerk te lezen, en om motivaties achter het ontwerp van de taal mee te krijgen. Om C++ te leren vind ik Bruce Eckel's Thinking in C++ prima, maar het vereist wel veel discipline van de lezer, omdat Eckel nogal veel tijd besteed aan object-georienteerd ontwerp, voordat het daadwerkelijk programmeren aan de orde komt. Dat is op zich erg goed (veel inleidingen in C++ focussen op het schrijven van code, en laten ontwerp en structuur van programma's een beetje achterwege) maar veel mensen willen graag meer een hands on approach waarbij ze meteen kunnen beginnen programmeren.

.oisyn schreef op vrijdag 15 juni 2007 @ 11:47:
VC 6.0 is crap, die CD moet je doormidden breken en ritueel verbranden. Vziw is Dev-C++ prima, als je echt met windows apps aan de gang wilt is de gratis te downloade Visual C++ 2005 Express wellicht een handigere optie.

Ik was vroeger ook een voorstander van Dev-C++, maar het is jammer dat de ontwikkeling ervan al jaren min of meer stil ligt. Tegenwoordig raad ik daarom Code::Blocks aan; makkelijk te installeren en werkt goed samen met zowel de GCC als MSVC compilers. Als je portable code wil schrijven is GCC i.m.o. de enige manier, en Code::Blocks zelfs is ook portable, wat handig is als je een project op een ander OS wil compileren.

Verder is Visual Studio Express ook een prima optie. Let er wel op dat je los de Platform SDK moet installeren om C/C++ code te kunnen schrijven, en je wat dingen moet aanpassen om de Platform SDK in Visual Studio te integreren. (Waarom hebben we daar geen FAQ over?!)

[Verwijderd]

mijn eerste ingeving was inderdaad ook om dit via function overloading te doen, ik vroeg me gewoon af of er een betere manier was. VC 6.0 is inderdaad crap. het werkt gewoon niet lekker en die CD gaat inderdaad ritueel verbrand worden.

het is inderdaad jammer dat Dev-C++ kwa ontwikkeling stil is komen te liggen. het is een zeer goede IDE maar ik denk dat ik Code::Blocks een poging ga geven. aangezien het zowel onder windows als linux werkt, GCC als compiler biedt en dus ook makkelijk mee te nemen is in mijn (K)Ubuntu switch.

ik zie het implementeren van PHP in C++ ook meer als een uitdaging die een leerzame ervaring zal bieden. tuurlijk zullen niet alle PHP eigenschappen naar C++ te vertalen zijn en dat is ook niet het streven. aangezien PHP deels een wrapper is naar onderliggende libs zoals Curl en zlib geeft het mij ook een kans om die libs op een wat lager nivo te leren kennen. naast de STL zelf natuurlijk. daarnaast zal ik ook zeker een duik nemen in de PHP broncode en die van andere projecten om te zien hoe anderen een bepaalde eigenschap hebben ge-implementeerd. komt mijn lokale PHP museum mirror toch nog goed van pas. ik heb alle release's sinds 4.0.0 tot de laatse build.

ik vond dat in 'C++ in 10 minuten' een goede balans werd gemaakt tussen het hoe je iets doet en waarom je iets doet. niet teveel erom heen maar gewoon to-the-point, geen 4 pagina's over het verschil van een signed en een unsigned integer maar gewoon in 1 duidelijke pagina met een paar schematische tekeningen erbij. ik denk dat ik daarom ook voor het logische vervolg kies: 'C++ in 21 dagen'.