Way to determine type of variable?

[Walter L. Preuninger II]

I would like to write a generic procedure that will take string or numeric
variables. I can not think of a way to make this more clear except to show
what I want.

int main(void)
{
int i=7;
char *s="/etc/filesystems";

generic(i);
generic(s);
generic("Hello" );
generic(2048);
exit(0);
}

should return:
7
/etc/filesystems
Hello
2048

so...

void generic( ???????)
{
???
}

I have looked at sprintf, varargs etc.

Could someone point me in the right direction?

Thanks,

Walter

[Jens.Toerring]

Walter L. Preuninger II <wa*****@texram p.net> wrote:

I would like to write a generic procedure that will take string or numeric
variables. I can not think of a way to make this more clear except to show
what I want. int main(void)
{
int i=7;
char *s="/etc/filesystems"; generic(i);
generic(s);
generic("Hello" );
generic(2048);
exit(0);
} should return:
7
/etc/filesystems
Hello
2048 so... void generic( ???????)
{
???
} I have looked at sprintf, varargs etc. Could someone point me in the right direction?

Sorry, but there's no right direction. Types are a compile
time concept and the type information is only used during the
compilation and is only implicitely contained in the resulting
executable (i.e. why certain machine instructions are used and
not others). So at run-time the type information does not exist
anymore and thus such generic functions are impossible - there
is no additional type information attached to a variable once
the code has been compiled.

All that is left is the question why you need such generic
functions (beside that it sometimes would be nice to have
them) - perhaps there's a different solution to your problem.

Regards, Jens
--
\ Jens Thoms Toerring ___ Je***********@p hysik.fu-berlin.de
\______________ ____________ http://www.toerring.de

[Mark A. Odell]

"Walter L. Preuninger II" <wa*****@texram p.net> wrote in
news:l5******** ***@10.224.0.25 4:

I would like to write a generic procedure that will take string or
numeric variables. I can not think of a way to make this more clear
except to show what I want.

int main(void)
{
int i=7;
char *s="/etc/filesystems";

generic(i);
generic(s);
generic("Hello" );
generic(2048);
exit(0);
}

should return:
7
/etc/filesystems
Hello
2048

so...

void generic( ???????)
{
???
}

I have looked at sprintf, varargs etc.

Could someone point me in the right direction?

Hate to say it, but C++ is the right direction for this. This is one of
those things, that in C, is rather clumsy to do, error prone, and doesn't
look very nice in the end.

--
- Mark ->
--

[Victor Nazarov]

"Walter L. Preuninger II" <wa*****@texram p.net> ÓÏÏÂÝÉÌ/ÓÏÏÂÝÉÌÁ × ÎÏ×ÏÓÔÑÈ
ÓÌÅÄÕÀÝÅÅ: news:l5******** ***@10.224.0.25 4...

I would like to write a generic procedure that will take string or numeric
variables. I can not think of a way to make this more clear except to show
what I want.

int main(void)
{
int i=7;
char *s="/etc/filesystems";

generic(i);
generic(s);
generic("Hello" );
generic(2048);
exit(0);
}

should return:
7
/etc/filesystems
Hello
2048

so...

void generic( ???????)
{
???
}

I have looked at sprintf, varargs etc.

Could someone point me in the right direction?

Thanks,

Walter

You'll need to implement polymorphism or use macrosses. If you really need
this facilities, try using C++ instead. You CAN implement something like
this in C, see http://ldeniau.home.cern.ch/ldeniau/html/oopc/oopc.html
for example

--
vir

[jacob navia]

"Walter L. Preuninger II" <wa*****@texram p.net> a écrit dans le message de
news:l5******** ***@10.224.0.25 4...

I would like to write a generic procedure that will take string or numeric
variables. I can not think of a way to make this more clear except to show
what I want.

int main(void)
{
int i=7;
char *s="/etc/filesystems";

generic(i);
generic(s);
generic("Hello" );
generic(2048);
exit(0);
}

should return:
7
/etc/filesystems
Hello
2048

so...

void generic( ???????)
{
???
}

I have looked at sprintf, varargs etc.

Could someone point me in the right direction?

Thanks,

Walter

This is not possible with standard C.
Generic functions aren't part of the standard language.

The lcc-win32 compiler implements generic functions
exactly like you want, but it isn't standard C, i.e. generic
functions are an *extension* of the language.

If you do not mind using extensions go to
http://www.cs.virginia.edu/~lcc-win32.

Within standard C you can write a function like this:

#define INTEGER 1
#define STRING 2
#define DOUBLE 3
union data {
int Type;
int integer;
double doublefloat;
float floatfloat;
char *string;
// add other cases here
};

void generic(union data Data)
{
switch (Data.Type) {
case INTEGER:
printf("%d\n",D ata.integer);
break;
case STRING:
printf("%s\n",D ata.string);
break;
// Add the other cases here
}
}

int main(void)
{
union data Data;
Data.integer = 7;
Data.Type = INTEGER;
generic(Data);
Data.string = "/etc/path";
Data.Type = STRING;
generic(Data);
Data.Type = DOUBLE;
Data.doublefloa t = 67.987;
generic(DOUBLE, Data);
/// etc
}

}

[Eric Sosman]

Walter L. Preuninger II wrote:

I would like to write a generic procedure that will take string or numeric
variables. I can not think of a way to make this more clear except to show
what I want.

int main(void)
{
int i=7;
char *s="/etc/filesystems";

generic(i);
generic(s);
generic("Hello" );
generic(2048);
exit(0);
}

should return:
7
/etc/filesystems
Hello
2048

so...

void generic( ???????)
{
???
}

I have looked at sprintf, varargs etc.

Could someone point me in the right direction?

The best you can get is something along the lines of

enum Type { INT, STRING, /* others ... */ );
generic(INT, i);
generic(STRING, s);
generic(STRING, "Hello");
generic(INT, 2048);

Or with a repackaging of essentially the same idea, you could get

struct { enum Type type;
union { int i; char *s; /* others ... */ } value;
} args;
args.type = INT; args.value.i = i; generic(args);
args.type = STRING; args.value.s = s; generic(args);
args.value.s = "Hello"; generic(args);
args.type = INT; args.value.i = 2048; generic(args);

Neither of these seems especially attractive, nor do any of
the other variations I can think of. They're ugly, they're
clumsy, and they're error-prone -- the compiler will not
detect the mistakes in

/* first form */
generic(STRING, 42);

/* second form */
args.type = INT; args.value.s = "Boom!"; generic(args);

The fundamental problem is that C is a statically-typed
language, meaning that the type of every expression is fixed
at compile time. True, <stdarg.h> (not <varargs.h>, BTW) can
evade this requirement, but only briefly: In order to access
the arguments corresponding to `...', you must use an expression
whose type is known and immutable. C is not Lisp.

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

[Drew MacDonald]

jacob navia wrote:

Within standard C you can write a function like this:

#define INTEGER 1
#define STRING 2
#define DOUBLE 3
union data {
int Type;
int integer;
double doublefloat;
float floatfloat;
char *string;
// add other cases here
};

Uh, that doesn't look right. Shouldn't it be something
more like:

struct data
{
int Type;
union values
{
int integer;
double doubleFloat;
float floatFloat;
char *string
// add other cases here
};
};

If the Type is in the union, then wouldn't Type and
integer overwrite each other?

Drew

[Walter L. Preuninger II]

<Je***********@ physik.fu-berlin.de> wrote in message
news:2l******** ****@uni-berlin.de...

Walter L. Preuninger II <wa*****@texram p.net> wrote:
[snip]
All that is left is the question why you need such generic
functions (beside that it sometimes would be nice to have
them) - perhaps there's a different solution to your problem.

Regards, Jens
--
\ Jens Thoms Toerring ___ Je***********@p hysik.fu-berlin.de
\______________ ____________ http://www.toerring.de

I needed a generic error printing routine, better than what perror()
provides.

incomplete code follows

char *filename="X";
char *buffer;
int size=65536;

file=fopen(file name,"rt");
if (file==NULL)
{
xerror("fopen failed",filenam e);
exit(1);
}
buffer=(char *)malloc(size);
if(buffer == NULL) {
xerror("malloc failed, size=",size);
}

I guess I could use sprintf to fill a buffer and print/pass that, but I
wanted to lessen the amount of code written.

I have written a macro for xerror that does pass argv[0], __FILE__, __LINE__
and errno to produce
../test:test.c:15: fopen failed:X for the fopen example above.

Thanks,

Walter

[Default User]

"Walter L. Preuninger II" wrote:

I would like to write a generic procedure that will take string or numeric
variables. I can not think of a way to make this more clear except to show
what I want.

int main(void)
{
int i=7;
char *s="/etc/filesystems";

generic(i);
generic(s);
generic("Hello" );
generic(2048);
exit(0);
}

should return:
7
/etc/filesystems
Hello
2048

so...

void generic( ???????)
{
???
}

I have looked at sprintf, varargs etc.

Could someone point me in the right direction?

Something like sprintf() is about as close as you are going to get. You
can use a variadic function or pass in void pointers, but in any case
you'll need to let the function know about the type.

One way would be a typed data struct:
struct data
{
void *datap;
int type;
};

Then set type when the data is created.


Brian Rodenborn

[jacob navia]

AAAAAArg!!!!

Right!

4 eyes see more than just two. Another proof of that old
wisdom.

It must be a structure with the type *outside* the union.

Sorry about this bug!

jacob