assignment problem with general pointers (VOID type )

[Jose]

Hey. I'm using jpeg.library and the pointer to the buffer I'm decompressing to is declared as APTR. Now the problem is that when I try to assign the value jpeg.library puts in it to another pointer VBCC complains sayint that it's an invalid type. If I try to cast it to the same type of pointer I'm copying it's value to, it complains saying that type VOID cannot be casted or something...
Maybe the easy way would be to copy it to some LONG first (haven't tryied it yet anyway...), but I wanted to know, is there a more elegant way around this?

[Jose]

By the way, the pointer I'm trying to copy the buffer pointer value to, was declared, if I remember correctly, something like:

Code: [Select]

struct Pixel
{BYTE Red;
 BYTE Green;
 BYTE Blue;
} *ImgPixelPosition;

 but I don't think this matters, it's just a pointer to a diferent type.

Hope the Pixel declaration doesn't coincide with some stuff on the Gfx library by the way, if I use it latter...

[Jose]

Bump.. :-(

[Trev]

So you're trying to assign a `APTR' (typedef void *APTR) to a `struct Pixel *'? Well, in C, this should work:

APTR ptr;
struct Pixel *pixel;

func(&ptr);
pixel = (struct Pixel *)ptr;

In C++, your compiler might let you do something like this:

APTR ptr;
BYTE red;

func(&ptr);
red = static_cast(ptr)->Red;
static_cast(ptr)->Red = 0xff;

Trev

[Jose]

@Trev

"So you're trying to assign a `APTR' (typedef void *APTR) to a `struct Pixel *'?"
Yes!

Thx for the tip. Not sure I uderstand the second part of the code (the C one).

func(&ptr); calls a function with an argument with a pointer to the ptr pointer correct? But for what?

pixel = (struct Pixel *)ptr;
This seems to be a normal cast.

Or did you mean:

func(&ptr);
void func(some type I don't know ptr, I guess void wouldn't work)
{pixel = (struct Pixel *)*ptr;
}

Ok, maybe this isn't what you mean.... :-D

Why da heck can't this be done easily in C :-o

[Jose]

Hey!!! Got one idea.
What about declaring Ptr as a Union with both types of pointers (struct Pixel * and APTR) ? :-D

By the way, since I'm an optimization freak, will the compiler make less efficient code like this, or will it simply remind the the Ptr variable can be both types. If I recall correctly the variable types in C are just like a list the compiler keeps to avoid the programmer making errors, shouldn't affect the code except for when a Union contains two or more types of diferent sizes, in this case the only difference would still be the size of the memory block reserved for the variable (being a size that could take the biggest type in the Union), but performance wise the code would be as fast right? :-D

I'm gonna try this when I get home, but some of you could say something about it... Maybe we're just all preparing to get drunk in the end of the year :-D

[Trev]

You don't need a union for this. In fact, using a union for a type conversion would be an incorrect use of a union. It's only safe to read from a member of a union if that member was the last member written to:

Code: [Select]


struct my_struct {
  union {
    int int_val;
    void* ptr;
  };
};

void some_func()
{
  struct my_struct ms;
  void* ptr;

  ms.int_val = 1;
  ptr = ms.ptr; /* UNSAFE--newer compilers should issue a warning */
}

Anyhow, you should use unions when you want to conserve memory and you know exactly how your compiler and linker organizes structures and data in general in memory.

The code samples from my previous message were just samples of casting in C/C++. func() was just a hypothetical function that took a pointer to a pointer as a parameter. This might be clearer:

Code: [Select]


struct sample_struct {
  int value1;
  int value2;
};

APTR func(void); /* hypothetical function returns a pointer to struct sample_struct as a APTR */

int main(void)
{
  APTR ptr;
  struct sample_struct* ss;

  ptr = func();
  ss = (struct sample_struct*)ptr;
  ss->value1 = 1;

  /* OR */

  ss = (struct sample_struct*)func();
  ss->value1 = 1;
}

Now might be a good time to go over the rules for casting in the C standard. :-) If you're not using C++, then you can ignore my static_cast sample.

Also note that these are just casting examples. Be sure to keep on eye on those pointers, especially if they point to memory that needs to be deallocated.

Trev

[Einstein]

Just a silly question as I'm not much at home in advanced C-programming: why does pointers in C need to be declared as certain types ? I figure this is a compiler-directive to have access to the different offsets in the varibales/structures/functions, am I correct ?  :-?

[Karlos]

Einstein wrote:
Just a silly question as I'm not much at home in advanced C-programming: why does pointers in C need to be declared as certain types ? I figure this is a compiler-directive to have access to the different offsets in the varibales/structures/functions, am I correct ?  :-?

That's about it, really. At a machine level, pointers are just addresses. In the 680x0 for example, a pointer can be any 32-bit value. You usually have to care about the size of the element pointed to when modifying them.

In (slightly) higher level languages such as C, you define a pointer as pointing to a particular type. This can be anything , from a byte to a complex structure.

For example, assuming we have 32-bit integers;

int x;
int myInt[4] = { 0, 1, 2, 3 };
int *pInt = &myInt[1]; /* points to the second integer in the array */

C then takes care to correctly do the maths when you operations like

x = *(++pInt); /* x = 2 */
x = *(--pInt); /* x = 1 */
x = pInt[2]; /* x = 3 */

On a system with 32-bit integers and 32-bit pointers, the actual value of pInt would be changing by 4 when you use ++/-- and the index scaled by 4 when you use [].

Having typed pointers also helps to prevent many problems that could otherwise arise when dealing with structures etc.  The compiler can see the definition of a structure and can therefore ensure that the -> operation can only access the defined members of that structure.

The void pointer was introduced to deal with the requirement of uninitialised/undefined memory. The void pointer is purely designed to simply hold the address of something and does not allow dereferencing or arithmetic of any kind (since no information about the thing pointed to is known).

[Einstein]

Thanks for the reply Karlos

[Jose]

Hey, it just stroke me, that must also be why it's not permited to do pointer arithmetic with type void right ? Since the compiler doesn't know the size of the type the void * pointer points to it can't do pointer arithmetic.

[Karlos]

Jose wrote:
Hey, it just stroke me, that must also be why it's not permited to do pointer arithmetic with type void right ? Since the compiler doesn't know the size of the type the void * pointer points to it can't do pointer arithmetic.

Exactly. As I said, void poiters cannot have any arithmetic applied to them and cannot be dereferenced.

Their sole purpose is to allow a pointer that can "point to anything" as a handle to raw memory.

[Jose]

Ups, hadn't read that part... :-)

[Karlos]

Jose wrote:
Ups, hadn't read that part... :-)

No, but you grasped it anyway, which is even better than someone telling you :-)