casting?

**audinue** · 07-19-2008

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

Let say I have a structure:

Code:

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

} _MEMORY_POOL, *_PMEMORY_POOL;

and a typedef:

Code:

typedef void *MEMORY_POOL;

Code:

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** · 07-19-2008

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** · 07-19-2008

Thanks Elysia.

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

**Elysia** · 07-19-2008

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** · 07-19-2008

where and when

Any clue, please?

**tabstop** · 07-19-2008

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** · 07-19-2008

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** · 07-19-2008

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** · 07-19-2008

Thank you for your attention.

So, I made a conclusion:

Code:

pstructure --> pvoid --> pstructure

doesn't affect performance at all.

But...

Code:

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** · 07-19-2008

Originally Posted by iMalc

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** · 07-19-2008

Originally Posted by audinue

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** · 07-19-2008

Code:

//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** · 07-19-2008

Corrected the above for what I was thinking.

**audinue** · 07-20-2008

Code:

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

:P

**Elysia** · 07-20-2008

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

Thread: casting?

Thread Tools

Search Thread

Display

casting?

Similar Threads

Advantages of c++ type casting over c type casting

Casting

casting the system exstracted date into seperate ints

Type casting

question about casting pointers/other types also??