从void **数组返回数据

Question

Suppose we have the following:

struct container
{
   void** array;
   function_pointer_typedef fp_t;
   int length;
};

void* get_data(const void* item){
   return item; //unsure. also produced warning.
}

void delete_element(container* c, void* item)
{
   /* 1. delete the array element pointed at by "item"
      2. reposition remaining array elements
   */
}

void* find_item(container* c, void* item)
{
   int i;
   for(i = 0; i < c->length; i++){
      if(c->fp_t(item, c->array[i]) == 0){
         return c->array[i];
      }
   }
}

Further suppose that fp_t returns 0 if the two things compared are equal to each other (other return values for the function pointer are unimportant now). I'm also assuming, to make things easier, that the item in the second argument of find_item will always be in the array.

I guess I'm having trouble understanding how void** works. In the get_data function, we're supplied as an argument a void* pointer to an array cell, which is a void* pointer to some data object. So how do we get that data object? I understand the user has to cast it for it to be useful, but I still don't know what I'm supposed to be returning. I also know you can't dereference a void* , so doing something like return *item; (which in my mind seems like what we're trying to do- just get the void* pointer at the array cell), compiles with warnings/errors.

I guess delete_element carries the same type of confusion for me. We're supplied a void* pointer item , which points to a void* pointer array cell that points to the actual data. So we need to dereference the item somehow so that we can delete the array cell.

Any ideas?

Answer 1

It's easy to get confused by void * and void ** . A void * is a generic container for any pointer-to-object. Any object pointer can be converted to void * and back again to the original value. (Note that a void * is not guaranteed to be able to hold a function pointer). It doesn't really matter what type of objects these functions are handling. They are storing and retrieving objects (that just happen to have the type void * ).

 struct container { void** array; function_pointer_typedef fp_t; int length; }; 

Your array member is simply a pointer to an array of objects.

---

 void* get_data(const void* item){ return item; //unsure. also produced warning. } 

I have no idea what this function is supposed to return, but the reason you're getting a warning from this is that you are removing a const qualifier. You are turning a (pointer to) read-only object into a writable object. This is not allowed in C. To get away with this, you have to cast away the const qualifier. ( return (void *)item; ).

If item really is a pointer to an array cell (converted to void * ), then you have to cast it to the original type before you dereference it to retrieve the object. ( return *(void **)item; ). But I really have no idea what this function is supposed to do. Ask your teacher.

---

 void delete_element(container* c, void* item) { /* 1. delete the array element pointed at by "item" 2. reposition remaining array elements */ } 

You're supposed to go through the array of objects until you find one that compares equal to item , remove it from the array by moving the following objects to fill that slot, and then adjust the length . The only thing you have to dereference is the array pointer, not the stored objects.

---

 void* find_item(container* c, void* item) { int i; for(i = 0; i < c->length; i++){ if(c->fp_t(item, c->array[i]) == 0){ return c->array[i]; } } } 

This function should probably return NULL if item is not found. Just return NULL; right before the functions closing brace.

Answer 2

int* is a pointer to int. Given int* x pointing to valid memory for each of the following, *x and x[0] references the memory x points to; x+1 points to the location sizeof(int) bytes after x, *(x+1) or x[1] references that location; x+2 points to the location sizeof(int)*2 bytes after x, and so on.

void is not type of object; so void* is a pointer to memory but not a pointer to something. Given void* y , *y , y[0] , y+1 , *(y+1) , etc simply don't make sense.

void* is a type of an object--it is a pointer to memory. Given void** z pointing to valid memory for each of the following, *z and z[0] references the memory z points to; z+1 points to the location sizeof(void*) bytes after z, and so on.

If it helps, pretend "void*" is spelled "pointer" (as if you are using typedef void* pointer ), and is on par with "int". So, if I have int q and pointer p, I can't do *q because q isn't a pointer to something, nor can I do *p because p isn't a pointer to something (strictly this is true). But you can assign int's to other int's, and assign pointer's to other pointers; and you can allocate memory for int* just as you can allocate it for pointer* , and dereference objects of type pointer* just as you can with int*.

That's enough to answer your question, but to do what you want to do generally depends on a few implementation details. If you're going to store memory as arrays of void* 's (aka, void** 's or "pointer*'s"), you will need to either require your user pass you a create function, or just allocate each element's memory themselves (or just handle it themselves, if you want to allow them to point to non-heap objects; it really depends on what you want to do; if you let them have items pointing to non-heap objects, though, you probably don't want to delete it). Your code could delete the items easily enough. How to remove items from this set is another implementation detail--depends on what you want to do.