Creative uses for variable argument list functions

[Spiros Bousbouras]

Every time I've seen an example of a variable argument list
function its functionality was to print formatted output. Does
anyone have examples where the function is not some variation
of printf ?

[Richard Heathfield]

Spiros Bousbouras said:

Every time I've seen an example of a variable argument list
function its functionality was to print formatted output. Does
anyone have examples where the function is not some variation
of printf ?

What a curious question! Well, let's see...

It's easy to come up with examples, of course - but rather harder to
come up with examples that might actually be useful. For example, one
might calculate a sum using 0 as a terminator (since 0 doesn't affect
the sum, this is not unreasonable), but why bother? One might just as
easily write a routine that sums the first n items in an array, which
would be far more useful.

I suspect that, if there is a good answer to your question, it might lie
in the realms of expression-parsing or something along those lines.

I look forward to reading other answers, hopefully from people who are
thinking more creatively than me today.

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Kenny McCormack]

In article <xI************ *************** ***@bt.com>,
Richard Heathfield <rj*@see.sig.in validwrote:

>Spiros Bousbouras said:

>Every time I've seen an example of a variable argument list
function its functionality was to print formatted output. Does
anyone have examples where the function is not some variation
of printf ?

What a curious question! Well, let's see...

It's easy to come up with examples, of course - but rather harder to
come up with examples that might actually be useful. For example, one
might calculate a sum using 0 as a terminator (since 0 doesn't affect
the sum, this is not unreasonable), but why bother? One might just as
easily write a routine that sums the first n items in an array, which
would be far more useful.

I suspect that, if there is a good answer to your question, it might lie
in the realms of expression-parsing or something along those lines.

I look forward to reading other answers, hopefully from people who are
thinking more creatively than me today.

The one time I used this was to write a "max" function, that would
return the maximum value from a list of numbers.

[Kenneth Brody]

Spiros Bousbouras wrote:

>
Every time I've seen an example of a variable argument list
function its functionality was to print formatted output. Does
anyone have examples where the function is not some variation
of printf ?

How about a version of strcat() that takes a list of strings, which
could be called like this:

StrCatList(MyBu ffer,MyBufferLe n,string1,strin g2,string3,NULL );

Yes, one could use sprintf() for this, but strcat-like functionality
is (most likely) more efficient.

--
+-------------------------+--------------------+-----------------------+
| Kenneth J. Brody | www.hvcomputer.com | #include |
| kenbrody/at\spamcop.net | www.fptech.com | <std_disclaimer .h|
+-------------------------+--------------------+-----------------------+
Don't e-mail me at: <mailto:Th***** ********@gmail. com>

[Robert Gamble]

On Jul 30, 12:38 pm, Spiros Bousbouras <spi...@gmail.c omwrote:

Every time I've seen an example of a variable argument list
function its functionality was to print formatted output. Does
anyone have examples where the function is not some variation
of printf ?

I once wrote a variable argument string concatenation function that
returned a new string consisting of a catenation of all the provided
strings. The variable argument facility is useful is when you need to
create a function that can operate on a variable number of items in
which it would be inconvenient or impossible to supply the items as an
array. Examples include the execl* functions in POSIX and functions
that accept placeholders for a prepared statement in a SQL API.

Robert Gamble

[Richard Heathfield]

Kenneth Brody said:

Spiros Bousbouras wrote:

>>
Every time I've seen an example of a variable argument list
function its functionality was to print formatted output. Does
anyone have examples where the function is not some variation
of printf ?

How about a version of strcat() that takes a list of strings, which
could be called like this:

StrCatList(MyBu ffer,MyBufferLe n,string1,strin g2,string3,NULL );

Yes, one could use sprintf() for this, but strcat-like functionality
is (most likely) more efficient.

Since it's my day for being dense, I suppose I might as well attract
some flak for messing up the implementation:

#include <stdarg.h>
#include <stddef.h>

int catstrlist(char *buf, size_t len, ...)
{
int rc = 1; /* insufficient memory */
const char *arg = "";

va_list ap = {0};

va_start(ap, len);

while(len 1 && arg != NULL)
{
if(*arg == '\0')
{
arg = va_arg(ap, const char *);
}
else
{
*buf++ = *arg++;
--len;
}
}
*buf = '\0';
if(arg == NULL)
{
rc = 0; /* all done successfully */
}

va_end(ap);
return rc;
}
/* driver */
#include <stdio.h>
#include <string.h>

int main(void)
{
int rc = 0;
char target[32] = {0};

rc = catstrlist(targ et,
sizeof target,
"Hello", "World", NULL);
printf("Expecte d [HelloWorld], "
"got [%s]: Expected 0, got %d\n", target, rc);

memset(target, 0, sizeof target);
rc = catstrlist(targ et,
sizeof target,
"Now", "Is", "The", "Hour", NULL);
printf("Expecte d [NowIsTheHour], "
"got [%s]: Expected 0, got %d\n", target, rc);

memset(target, 0, sizeof target);
rc = catstrlist(targ et,
sizeof target,
"WayTooManyInpu tCharacters",
"In", "This", "Sequence", NULL);
printf("Expecte d [WayTooManyInput CharactersInThi s], "
"got [%s]: Expected 1, got %d\n", target, rc);

return 0;
}

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Eric Sosman]

Kenneth Brody wrote On 07/30/07 13:33,:

Spiros Bousbouras wrote:

>>Every time I've seen an example of a variable argument list
function its functionality was to print formatted output. Does
anyone have examples where the function is not some variation
of printf ?

How about a version of strcat() that takes a list of strings, which
could be called like this:

StrCatList(MyBu ffer,MyBufferLe n,string1,strin g2,string3,NULL );

Side-issue: Question 5.2 in the comp.lang.c Frequently
Asked Questions (FAQ) list <http://www.c-faq.com/explains
why this is *not* the right way to call such a function.

To the original point: The variable argument list is
best avoided except when it's unavoidable, because it offers
so many opportunities for error. The principal difficulty
is that the compiler does not know your conventions for the
arguments, and thus can't warn when you violate your own
rules accidentally -- as above, for example. You get the
dubious pleasure of having your code compile successfully
and then chasing down the undefined behavior at leisure.

That, I think, does a lot to explain the relative rarity
of varargs. It's more or less unavoidable in I/O (where it
gives you not only the ability to pass argument lists of
varying lengths, but also of varying composition), but in
other settings people usually try to make their interfaces
less error-prone by finding ways to use fixed argument lists.

--
Er*********@sun .com

[dan]

On Jul 30, 8:38 am, Spiros Bousbouras <spi...@gmail.c omwrote:

Every time I've seen an example of a variable argument list
function its functionality was to print formatted output. Does
anyone have examples where the function is not some variation
of printf ?

I got thinking the same thing recently. Can variable argument list
functions be used to make a function able to handle int, long, or
float, depending on what is passed? As a simple example, a MAX
function, as someone else mentioned, that could deal with different
number types.

Is yes, would that be a good idea, or just better to write separate
functions?

Daniel Goldman

[Fred Kleinschmidt]

"Spiros Bousbouras" <sp****@gmail.c omwrote in message
news:11******** *************@b 79g2000hse.goog legroups.com...

Every time I've seen an example of a variable argument list
function its functionality was to print formatted output. Does
anyone have examples where the function is not some variation
of printf ?

One example that comes to mind is on Unix/Linux using Xt functions
such as XtVaSetValues( object, ..., NULL )
where ...,NULL represents a NULL-terminated list of
resource name/value pairs to set on the specified object.
--
Fred L. Kleinschmidt
Boeing Associate Technical Fellow
Aero Stability and Controls Computing

[Walter Roberson]

In article <11************ **********@d30g 2000prg.googleg roups.com>,
dan <da*******@yaho o.comwrote:

>I got thinking the same thing recently. Can variable argument list
functions be used to make a function able to handle int, long, or
float, depending on what is passed? As a simple example, a MAX
function, as someone else mentioned, that could deal with different
number types.

Yes, but keep in mind that the mechanisms have no inherent way
to find out what the type of the passed variable was, and so must
be told (and so must hope that the teller didn't accidently
misrepresent the types.) For example, you could have

GenericOutputTy pe MYMAX(argtypein dicator, ...)

GenericOutputTy pe perhaps being void* or a union type -- something
allowing you to return different types depending on the inputs.
--
Okay, buzzwords only. Two syllables, tops. -- Laurie Anderson