Re: void* passed as funtion parameters?
Robby wrote:
Hello Igor,
Why? Are you being charged per line of code?
The code in the function below really doesn't mean much but its just to
illustrate that keeping the cast(s) doesn't get rid of the redundance in the
f1() function. I showed an example below where suppose I have more code
residing in f1(), keeping the casts don't solve the problem. I understand the
part about the casts, but am I supposed to end up with something like this
for all my functions?
============================
typedef struct tag_pc {
long LK__F1;
long LK__F2;
long h;
} pc;
typedef struct tag_ab {
long LK__F1;
long LK__F2;
long h;
} ab;
typedef struct tag_cd {
long LK__F1;
long LK__F2;
long h;
} cd;
void f1(void *x, int type, int z)
{
int y;
pc *p = x;
ab *q =x;
cd *r =x;
switch(type)
{
case 1:
for(y=0; y<100; y++)
{
if(y==z)
{
p->LK__F1 = y;
p->LK__F2 = (y+12);
}
p->h = y+z;
}
break;
case 2:
for(y=0; y<100; y++)
{
if(y==z)
{
q->LK__F1 = y;
q->LK__F2 = (y+12);
}
q->h = y+z;
}
break;
case 2:
for(y=0; y<100; y++)
{
if(y==z)
{
r->LK__F1 = y;
r->LK__F2 = (y+12);
}
r->h = y+z;
}
break;
}
}
int main()
{
void *x;
x = malloc (sizeof (struct tag_pc));
f1(x, 1);
x = malloc (sizeof (struct tag_ab));
f1(x, 2);
x = malloc (sizeof (struct tag_cd));
f1(x, 3);
free(x);
return 0;
}
===========================
I find f1() very redundant, and bulky, wouldn't you agree?
Igor, I am looking for an alternative, and gentlemen in this post have
listed the alternatives whereby the way I see it, asides from what was
proposed, theres not much more I can do becuase its C.
Thanks all for your help!
Robby:
As Igor says, since your three structures seem to be identical:
(a) there doesn't seem much point to having three of them
(b) it doesn't matter which one you cast the void* to, so you only need one
version of the function.
But to make it a bit more interesting, suppose the structures were different,
but with some common elements that you put at the beginning:
typedef struct tag_pc {
long LK__F1;
long LK__F2;
long h;
// other pc stuff
} pc;
typedef struct tag_ab {
long LK__F1;
long LK__F2;
long h;
// other ab stuff
} ab;
typedef struct tag_cd {
long LK__F1;
long LK__F2;
long h;
// other cd stuff
} cd;
Then you might do
typedef struct tag_base {
long LK__F1;
long LK__F2;
long h;
} base;
void f1(void *x, int z)
{
int y;
base *p = x;
for(y=0; y<100; y++)
{
if(y==z)
{
p->LK__F1 = y;
p->LK__F2 = (y+12);
}
p->h = y+z;
}
}
This will work because pc, ab, cd and base all have the same layout for their
common elements.
The struct base is not really necessary (you could cast to one of the other
types, but it makes the solution more symmetric between the types.
In C++ you could derive pc, ab and cd from base and pass a base* instead of a
void*. (You could also use templates as Alex suggested). In C++ it is very
rarely necessary to "cheat" the type system, but it can often save a lot of
effort in C.
--
David Wilkinson
Visual C++ MVP