casting?

[audinue]

Btw, I want to explicitely 'hide' my structure.

Let say I have a structure:

typedef struct
{
    void *base;
    unsigned short initialSize;
    unsigned short increment;
    unsigned int allocated;
    unsigned int elementSize;

} _MEMORY_POOL, *_PMEMORY_POOL;

and a typedef:

typedef void *MEMORY_POOL;

void *_pcheck(MEMORY_POOL p, unsigned int offset)
{
    if(offset >= ((_PMEMORY_POOL)p)->allocated)
        if((((_PMEMORY_POOL)p)->base = realloc(((_PMEMORY_POOL)p)->base, (((_PMEMORY_POOL)p)->allocated = ++((_PMEMORY_POOL)p)->increment * ((_PMEMORY_POOL)p)->initialSize) * ((_PMEMORY_POOL)p)->elementSize)) == NULL)
            abort();

    return ((_PMEMORY_POOL)p)->base;
}

Is it a good idea to do something like this?

[Elysia]

I would still suggest you typedef MEMORY_POOL to just void and use MEMORY_POOL* to increase the visibility and fact that it is a pointer.
Pointer typedefs can cause headaches.

[audinue]

Thanks Elysia.

Btw, when we do a lot of casting, doesn't that affect performance?

[Elysia]

Depends on what you do, where and when. And it also depends on the hardware.
I wouldn't say it's bad. It's essential to languages such as C.

[audinue]

where and when

Any clue, please?

[tabstop]

I guess you mean casting things to your structure and back? I would be surprised if that made any difference at all; the only thing I can think of that would cause problems is mis-alignment, but that shouldn't ever actually happen. (In other words, I would expect p->base, where p is a _PMEMORY_POOL, and ((_PMEMORY_POOL)p)->base, where p is a void *, to generate the exact same assembly: load p, add the offset for base, and fetch from that memory location.)

[Elysia]

Especially if you try to change sizes of things. That means extra (maybe) instructions or cycles to convert the data.
I can't really say, though. I'm not an expert on the hardware topic.

[iMalc]

Casting pointers only tells the compiler to interpret data differently. Casts don't actually take a performance hit on their own.
It's accessing the data in the specified format that could be more or less efficient, but no more so than if it were already of that type.

[audinue]

Thank you for your attention.

So, I made a conclusion:

pstructure --> pvoid --> pstructure

doesn't affect performance at all.

But...

pstructureA --> pvoid --> pstructureB

will make a mis-alignment.

...

Out of the box:
Btw, I think I will migrate to C++...
I getting problem with data types in C.
When I tried to implement stack in C, should I make str_stack()?, int_stack()?, char_stack()?, void_stack()?, arrrrrgghhhh... *confuse* I'm going crazy because of void* XP

[King Mir]

C-style casts, reinterpret_cast, and static_cast only tell the compiler to interpret data differently. They don't actually take a performance hit on their own.
It's accessing the data in the specified format that could be more or less efficient, but no more so than if it were already of that type.

Not true for primitive conversions. For example static or C casting an chat to a int will take performance hit, because it has to sign extend the value.

But this isn't C++, so it's better not to bring C++ terms in. Suffice to say that casting pointers in C will never take a performance hit.

As an aside: it is not allowed to cast function pointers to non function pointers. Trying to do this may result in a performance hit, assuming you compiler allows you.

[Elysia]

Out of the box:
Btw, I think I will migrate to C++...
I getting problem with data types in C.
When I tried to implement stack in C, should I make str_stack()?, int_stack()?, char_stack()?, void_stack()?, arrrrrgghhhh... *confuse* I'm going crazy because of void* XP

Depends on the complexity and purpose of the stack. Is it merely to work with pointers, then void_stack might do, otherwise you're going to have problems and probably have to duplicate some code or create a devious work-around.
Suffice to say, C++ can handle this with ease and with more speed than C probably (if you choose to use methods with function pointers, or such).

[robwhit]

//C99 :
typedef struct
{
    void *base;
    unsigned short initialSize;
    unsigned short increment;
    unsigned int allocated;
    unsigned int elementSize;

} MEMORY_POOL_INTERNAL;
struct MEMORY_POOL;
void *_pcheck(MEMORY_POOL *p, unsigned int offset)
{
    MEMORY_POOL_INTERNAL *p_i = (MEMORY_POOL_INTERNAL *) p;
    if(offset >= p_i->allocated)
        if((p_i->base = realloc(p_i->base, (p_i->allocated = ++p_i->increment * p_i->initialSize) * p_i->elementSize)) == NULL)
            abort();

    return p_i->base;
}

*ahem*

[iMalc]

Corrected the above for what I was thinking.

[audinue]

#define p ((_PMEMORY_POOL)p)
/*
   ... p-> ...
*/
#undef p

:P

[Elysia]

I hope you were sarcastic, because that is a very horrible hack