Functions that accept various type?

[QQ]

I have two 'mean' functions, one to handle an integer array, and one to
handle a double array (see code provided below). Is there a way to write a
single 'mean' function that would take either an array of ints or an array
of doubles?

Thanks.

-------------------
#include <stdio.h>

double int_mean (int * array, int num_elem)
{
int i, sum = 0;
for (i = 0; i < num_elem; i++)
sum += array[i];
return (double)sum/(double)num_elem;
}

double double_mean (double * array, int num_elem)
{
int i;
double sum = 0.0;
for (i = 0; i < num_elem; i++)
sum += array[i];
return sum/num_elem;
}

int main ()
{
int i;
int array_size = 5;
int * int_array = (int *)malloc(sizeof(int) * array_size);
double * double_array = (double *)malloc(sizeof(double) * array_size);
for(i = 0; i < array_size; i++)
{
int_array[i] = 0;
double_array[i] = 0.0;
}
int_array[1] = 4;
double_array[3] = 2.1;

printf ("%lf, %lf\n", int_mean (int_array, array_size), double_mean
(double_array, array_size));

return 1;
}

[Jack Klein]

On Fri, 10 Dec 2004 22:49:23 -0500, "QQ" <q@q.q> wrote in comp.lang.c:

I have two 'mean' functions, one to handle an integer array, and one to
handle a double array (see code provided below). Is there a way to write a
single 'mean' function that would take either an array of ints or an array
of doubles?

Thanks.
Yes, but it doesn't save you much.
-------------------
#include <stdio.h>
enum array_type { INT, DOUBLE };

double int_mean (int * array, int num_elem)
{
int i, sum = 0;
for (i = 0; i < num_elem; i++)
sum += array[i];
return (double)sum/(double)num_elem;
}

double double_mean (double * array, int num_elem)
{
int i;
double sum = 0.0;
for (i = 0; i < num_elem; i++)
sum += array[i];
return sum/num_elem;
}
Now replace these two functions with this one:

double mean(void * array, int num_elem, array_type type)
{
double result = 0.0;

if (INT == type)
{
/* code from your int_mean function, change */
/* return statement to: */
result = (double)sum/num_elem; /* only need to cast one */
}
else if (DOUBLE == type)
{
/* code from your double_mean function */
}
else
{
/* decide if you are happy with just returning 0.0, */
/* or calling exit() or abort() or some other error */
/* handling */
}
return result;
}
int main ()
{
int i;
int array_size = 5;
int * int_array = (int *)malloc(sizeof(int) * array_size);
double * double_array = (double *)malloc(sizeof(double) * array_size);
for(i = 0; i < array_size; i++)
{
int_array[i] = 0;
double_array[i] = 0.0;
}
int_array[1] = 4;
double_array[3] = 2.1;

printf ("%lf, %lf\n", int_mean (int_array, array_size), double_mean
(double_array, array_size));

return 1;
}

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Antoine Mathys]

I have two 'mean' functions, one to handle an integer array, and one to
handle a double array (see code provided below). Is there a way to write a
single 'mean' function that would take either an array of ints or an array
of doubles?

Yes, it is called C++.

[Malcolm]

"QQ" <q@q.q> wrote

I have two 'mean' functions, one to handle an integer array, and one to
handle a double array (see code provided below). Is there a way to write a
single 'mean' function that would take either an array of ints or an array
of doubles?

The C++ way is to use templates.

In C, you could use a typedef to toggle between versions. If the functions
are static this means you can have two versions in one program, but
unfortunately not in scope at the same time.

There is no other practical way of doing it.

For the general problem, however, you would solve it by writing

/*
take mean of addable objects
el - elemets
elsize - size of each element
N - number of elements
add - function to add an element to a double
*/
double mean(void *el, size_t elsize, int N, double (*add)(void *, double))
{
int i;
double tot = 0;
unsigned char *ptr = el;

for(i=0;i<N;i++)
tot += add( &ptr[i*elsize], tot);

return tot/N;
}

This is obviously ridiculous for "mean", but the general principle can be
used for more complex problems, where it may make some sense.

[Herbert Rosenau]

On Sat, 11 Dec 2004 03:49:23 UTC, "QQ" <q@q.q> wrote:

I have two 'mean' functions, one to handle an integer array, and one to
handle a double array (see code provided below). Is there a way to write a
single 'mean' function that would take either an array of ints or an array
of doubles?

Thanks.

-------------------
#include <stdio.h> #include <stdlib.h>
missing

double int_mean (int * array, int num_elem)
{
int i, sum = 0;
for (i = 0; i < num_elem; i++)
sum += array[i];
return (double)sum/(double)num_elem;
}

double double_mean (double * array, int num_elem)
{
int i;
double sum = 0.0;
for (i = 0; i < num_elem; i++)
sum += array[i];
return sum/num_elem;
}
replace with

/* closed in itself */
#define MEAN(sum, a, n) { \
int i; \
for (i = 0, sum = 0; i < (n)); i++) \
sum += a[i]; \
}

OR
/* requires defition of i outside this macro */
#define MEAN(sum, a, n) \
for (i = 0, sum = 0; i < (n); i++) \
sum += a[i];

int main ()
{
int i;
int array_size = 5;
int * int_array = (int *)malloc(sizeof(int) * array_size); superflous cast, hiding the fact that stdlib.h is not included,
producing undefined behavior.

int isum;
double * double_array = (double *)malloc(sizeof(double) * array_size); superflous cast, hiding missing #include <stdlib.h>, producing
undefined behavior
double dsum;
for(i = 0; i < array_size; i++)
{
int_array[i] = 0;
double_array[i] = 0.0;
}
int_array[1] = 4;
double_array[3] = 2.1;

printf ("%lf, %lf\n", int_mean (int_array, array_size), double_mean
(double_array, array_size)); mismatch type in format list with actual parameter

replace with
MEAN(isum, int_array, array_size);
MEAN(dsum, double_array, array_size);
prinf("%d, %lf\n", isum, dsum);

return 1;
}

--
Tschau/Bye
Herbert

Visit http://www.ecomstation.de the home of german eComStation
eComStation 1.2 Deutsch ist da!

[Lawrence Kirby]

On Fri, 10 Dec 2004 22:49:23 -0500, QQ wrote:

I have two 'mean' functions, one to handle an integer array, and one to
handle a double array (see code provided below). Is there a way to write a
single 'mean' function that would take either an array of ints or an array
of doubles?
It can be done as others have indicated. It isn't usually a good solution
however.
Thanks.

-------------------
#include <stdio.h>

double int_mean (int * array, int num_elem) {
consider making that const int *array
int i, sum = 0;
for (i = 0; i < num_elem; i++)
sum += array[i];
return (double)sum/(double)num_elem;
}

Also consider that INT_MAX need not be larger than 32767. Are you sure
that is always enough to represent the sum for the array? Could num_elem
be zero?

Lawrence

[Antoine Mathys]

>>double int_mean (int * array, int num_elem)

...
return (double)sum/(double)num_elem;
...
double double_mean (double * array, int num_elem)
...
printf ("%lf, %lf\n", int_mean (int_array, array_size), double_mean
(double_array, array_size));

mismatch type in format list with actual parameter

No way, both functions return a double. You could be a bit more careful
before correcting others.