about type casting...

hello...I'm designing an interface that each module of my app should follow. It has a funcion for initialization, one for finalization ecc. Their prototypes are like that:

Code:

---

int Init(void* ptr);
void Destroy();
//ecc.

---

The problem is that the Init function of each module should use ptr not as a void*, but as a type different from module to module. Each implementation of the Init function in the modules use ptr as pointer to a proprietary type. So I tried doing so:

Code:

---

int Init(void* ptr)
{
    (strMyStruct*) ptr;
    ptr->a = 10;
}

---

but VC++ 2005 gives me an error sayng that ptr is a pointer to void instead of a struct.

So is there a way to cast ptr only one time for all the scope of the function?

Yes, but you will need to assign it to another variable

Code:

---

int Init (void * ptr) {
  strMyStruct * structptr = (strMyStruct*) ptr;
  structptr->a = 10;
}

---

QuantumPete

You are just casting ptr to strMyStruct*, and then using ptr as a void*. You probably wanted to write:

Code:

---

int Init(void *ptr)
{
    strMyStruct *myptr = ptr;
    myptr->a = 10;
}

---

But then do you really need to make ptr a void* in the first place? If you want to be consistent, each "module" would have an Init() function that takes a pointer, though since there are no namespaces in C, you would need to name it say, MyStructInit().

I know that a pointer is just 4bytes (or 8bytes)...but I don't like the idea to have to copy the variable only to use it as a different type...really there aren't other ways? Also why the line

(strMyStruct*) ptr;

compiles fine? What sense should it have?

laserlight...thanks for your answer...but I don't understand what you're sayng...could you explain it a bit better?

Quote:

---

Originally Posted by ZeroMemory

I know that a pointer is just 4bytes (or 8bytes)...but I don't like the idea to have to copy the variable only to use it as a different type...really there aren't other ways? Also why the line

(strMyStruct*) ptr;

compiles fine? What sense should it have?

---

It casts ptr to a pointer-to-strMyStruct, and then ... ignores it. It doesn't change its type on a permanent basis (such a thing isn't possible).

Either cast it every time you use it, or (as suggested) create an actual pointer-to-strMyStruct to use.

You can't permnently change the type of a variable in C.
Either you create a new variable and tell the assign the old one to it (and tell the compilr to treat your pointer as the same type as the new).
Or you can tell the compiler to temporarily treat the pointer as a new type:

((strMyStruct*)ptr)->a = 10;

Using...

(strMyStruct*) ptr;

...is actually a valid line. Unfortunately, it does nothing by itself, so that's why it compiles but you get no effect. Some compiler will warn you that the line does nothing, as well.

Code:

---

((strMyStruct*)ptr)->a = 10;

---

But people are typically never a fan of that type of coding... they always grumble something about "human readable" or some non-sense (And yes, I do cast like that all the time--sue me).

I don't find a problem with it.
I don't find a problem with most things.
It's big, complex lines and stuff you try to stuff into one line that makes it unreadable.
When it becomes long, break it into several parts. At those times, a temp variable with the new type, as shown above, really shines.

Code:

---

(*(strMyStruct*)ptr).a = 10;

---

Heh.. I think when one is doing pointer math it is useful.

Code:

---

((myStruct *)((int *)p + 56))->fps = 30.0f;

---

Sometimes I augment these "cluttered" lines with simple comments like.

Quote:

---

/* Matt: If you don't understand, just ask me. */

---

Or the ever popular.

Quote:

---

/* Matt: If you don't understand, you may wish to seek a new career. */

---

Quote:

---

Originally Posted by master5001

Code:

---

(*(strMyStruct*)ptr).a = 10;

---

---

This could probably be simplified... again because we typicall don't do "(*var).", but "var->", so it should be

Code:

---

((strMyStruct*)ptr)->a = 10;

---

Quote:

---

Code:

---

((myStruct *)((int *)p + 56))->fps = 30.0f;

---

---

This one is horrible.

Code:

---

int* pTemp = (int*)p + 56;
((strMyStruct*)pTemp)->fps = 30.0f;

---

So much easier to read.

My first one was actually a sample off of someone else's currently circulating thread. The int * thing I do frequently when parsing binary files. I will do stuff like that to skip over x blocks of data. But yes, it is not the clearest, and no I won't change my style.

I'm not saying you should change your style, but it would be best (and most readable) if broken into two lines, as I demonstrated.
Anyway, it was just a demonstration as to why people can find it unreadable, right?

Indubitably! So point well taken. And don't worry, I don't feel like my style is being threatened or challenged. In fact, if anything I basically said "here is my ugly code, don't let me see any of you doing this."

Hehehe. Gotcha!

:) thanks...

So it's impossible...well...anyway I'm embedding my modules in DLL files. What if, in the host app, I declare

Code:

---

typedef int (WINAPI* LPFUNC_INIT)(void*);

---

then in the DLL file I use:

Code:

---

int WINAPI Init(strMyStruct* ptr)
{
}

---

it should work allright...is it true?

No. Never. Absolutely not.
Types must match, or you get undefined behavior.

but the type of a pointer is only an indication to the compiler on how to handle its arithmetic, isn't it? So why should it not work?