type swapping?

Okay, I'm writing a function where it's going to have to deal with three possible data types in an identical manner...

currently, I'll have to do the following

Code:

   void *arrayPtr;
   if(datatype == 1)
   {
        arrayPtr = calloc(5, sizeof(int));
        int holder;
    }
    else if(datatype == 2)
    {
        arrayPtr = calloc(5, sizeof(double));
        double holder;
    }
    else if(datatype == 3)
    {
        arrayPtr = calloc(5, sizeof(float));
        float holder;
    }

now, is it possible to create a function or macro that can let me replace the top with something like this?

Code:

void *arrayPtr;
arrayPtr = calloc(5, sizeof(TYPECONV(datatype)));
TYPECONV(datatype) holder;

Code:

#define TYPECONV(t)\
(t==1?sizeof(int):\
 t==2?sizeof(double):\
 t==3?sizeof(float):\
 sizeof(char))

Originally Posted by Sebastiani

Code:

#define TYPECONV(t)\
(t==1?sizeof(int):\
 t==2?sizeof(double):\
 t==3?sizeof(float):\
 sizeof(char))

This works for the sizeof part, but the tricky part is this:

Code:

TYPECONV(t) newvariable //<---- Declaring a new variable in the scope with the same datatype...

Is this possible at all in C, or should I stop barking up the wrong tree?

Sounds to me like you need to use a union

Other than the part where I can't find enough information to determine if this works, unions sounds just like what I need...

Code:

#define TYPESWAP(x)\
(t==1?swapvar.intvalue\
 t==2?swapvar.floatvalue:\
 swapvar.doublevalue)


union vartype
{

int intvalue;
float floatvalue;
double doublevalue;
}swapvar;

will sizeof(swapvar.intvalue) give me the size of an int variable?
what about union vartype *swapPtr?
is can *swapPtr be used as a pointer to a variable with the datatype of one of the members?

Nevermind, tried it out myself, and the only thing I ever got was errors...
When I compile, I get this error:

20 C:\Dev-Cpp\prototyping\typeconv.c invalid lvalue in unary `&'

Posting code...
Any ideas how to make this work?

Code:

#define TYPESWAP(t)\
(t==1?swapvar.intvalue:\
 t==2?swapvar.floatvalue:\
 swapvar.doublevalue)


union vartype
{

int intvalue;
float floatvalue;
double doublevalue;
}swapvar;

int main(int argc, char *argv[])
{

printf("inserting test int: ");
scanf("%d", &TYPESWAP(1));
printf("%d\n", TYPESWAP(1));
system("PAUSE");	
return 0;
}

change the scanf call to:

Code:

scanf("%d", (int *)&swapvar);

Edit: It appears it doesn't like what the conditional statement that the macro expands to inside scanf.

Inside of printf you will need to cast it to the right type if its not a double. ie:

Code:

printf("%d", (int)TYPESWAP(1));

Which actually defeats the reason I wanted to try that out in the firstplace, so nevermind.
Thanks anyway...

Don't ever say nevermind there is always a way

Code:

typedef union vartype{
int intvalue;
float floatvalue;
double doublevalue;
} vartype;

now

Code:

var=vartype{1}; /*this is an int*/

I think this would work. But really the union is sizeof largest element. Will this work(no compiler on me!)

>I think this would work.
Why?

>Which actually defeats the reason I wanted to try that out in the firstplace, so nevermind.
Using scanf and printf in a type independent way is virtually impossible. Even where you don't need a cast, you still need to match the format modifier to the desired type.

>Which actually defeats the reason I wanted to try that out in the firstplace, so nevermind.
Using scanf and printf in a type independent way is virtually impossible. Even where you don't need a cast, you still need to match the format modifier to the desired type.

actually that was a program to test and see if I can make the program automatically treat the union as one of the members without having to specifically calling the member.

essentially, what I was looking for, was either a way to make the union call the apropriate member by doing something like this:

myownfunction( SELFCONVERTINGUNION(datatype));

as opposed to having to do this

Code:

switch(datatype)
{

case 1:
 
myownfunction(unionvar.member1);
break;
case 2:

myownfunction(unionvar.member2);
break;
.
.
.
}

/whistle

Code:

  #define INPUT(x) \
  ( x == 1 ? scanf("%d", &unionvar) : \
  	x == 2 ? scanf("%f", &unionvar.floatvalue) :\
 	scanf("%f", &unionvar.doublevalue) \
  )
   
   #define OUTPUT(x) \
  ( x == 1 ? printf("%d\n", unionvar) : \
   	x == 2 ? printf("%f\n", unionvar.floatvalue) :\
   	printf("%f\n", unionvar.doublevalue) \
  )
   
   #include <stdio.h>
   
   int main(void)
   {
   union
   {
 	int intvalue;
 	float floatvalue;
 	double doublevalue;
   }unionvar;
   
    INPUT(1);
   OUTPUT(1);
 
    INPUT(2);
   OUTPUT(2);
 
    putchar('\n');
 
    return 0;
   }

Sorry for spacing. Not at home and using a different editor and browser