C automatic-expandable array of pointers

Question

QUESTION ANSWERED AT END OF PAGE. FULLY WORKING CODE.

Hello, I would like to do in C what I have asked in the title, however, I don't know how to accomplish it. I have done this in C++ thanks to templates but à la C. Here is the fully functional C++ code: List.h (simple database)

*I wonder now if with void pointers I can emulate the code. The problem is that I've seen a link stating that void * should be avoided because it can cause more trouble than it can solve.

Basically it is a "smart-array" that stores pointers to the variables themselves. If I know the size of each pointer and the size of each structure pointed to, simple mallocs and reallocs should do right?

typedef struct
{
  void **list;

  // internal
  int last_item_index;
  size_t element_size; // size of each pointer
  int elements;        // number of currently allocated elements
  int total_size;      // >= #elements so that we don't have to always call malloc
  int tweak_request_size; // each time the list grows we add this # of elements

} List;
// a shot at an addCopy function
// it deepcopies the object you pass in
List_addCopy(List *db, void *ptr_to_new_element)
{
  ... // grow **list
  // alloc and copy new element
  db->list[db->last_item_index+1] = malloc(element_size); // WORKS?
  // HOW TO COPY THE ELEMENT TO HERE IF IT IS A STRUCTURE FOR INSTANCE???
  ...
}

or
// a shot at an assign function 
// (allocate the elements yourself then pass the pointer to the List)
List_assign(List *db, void *ptr_to_new_element)
{
  db->List = realloc(db->List, element_size*(elements+tweak_request_size));
  db->List[db->last_item_index+1] = ptr_to_new_element;
}

// Usage example

List db; // our database
struct funky *now = (funky*)malloc(sizeof(funky));

funky->soul = JamesBrown;

List_addCopy(db, funky);

if (list[0]->soul == JamesBrown)
  puts("We did It! :D");

If I alloc everything outside and just pass the pointers to the List I guess the only problem is the void **.

Is List_add possible? Only with callbacks that do the alloc of the element and / or copy it?

Is List_assign possible? I don't want to have a lot of work and end up with unreliable software.

Thanks a lot and sorry for the convolution in the writing :p

If you know the size of the element, and it's a simple, flat data structure (no pointers to anything that also needs to be copied), just memcpy it over. — Anon.
– Anon., Commented Jan 26, 2011 at 1:30
And that won't pose a problem? Using void * * ? I've seen a thread saying that void * * should be avoided as results can be mixed: c-faq.com/ptrs/genericpp.html Thanks — Alberto
– Alberto, Commented Jan 26, 2011 at 11:40

Trinidad · Accepted Answer · 2019-06-25 10:10:14Z

1

You can avoid void* with something like this:

#include <stdio.h>
#include <stdlib.h>

#define List(T) \
    typedef struct { \
        T** items; \
        int count;  \
    } List_ ## T ;\
    \
    List_ ## T * List_ ## T ## _New() { \
        List_ ## T * list = (List_ ## T *) malloc(sizeof(List_ ## T)); \
        list->count = 0; \
        return list; \
    } \
    \
    void List_ ## T ## _Add(List_ ## T *list, T * data) { \
        printf("%d\n", ++list->count); \
    } \
    void List_ ## T ## _Del(List_ ## T *list, int index) { \
        printf("%d\n", --list->count); \
    }

/* define just one list per type */
List(int);
List(double);

int main()
{
    int a, b, c;
    double d, e;
    List_int *l1;
    List_double *l2;

    l1 = List_int_New();
    List_int_Add(l1, &a);
    List_int_Add(l1, &b);
    List_int_Add(l1, &c);
    List_int_Del(l1, 0);
    List_int_Del(l1, 0);
    List_int_Del(l1, 0);
    free(l1);

    l2 = List_double_New();
    List_double_Add(l2, &d);
    List_double_Add(l2, &e);
    List_double_Del(l2, 0);
    List_double_Del(l2, 0);
    free(l2);

    return 0;
}

That's a poor man's template =)

edited Jun 25, 2019 at 10:10

answered Jan 26, 2011 at 2:18

Trinidad

2,8562 gold badges27 silver badges44 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Alberto Over a year ago

Thanks! I got the idea, it seems to be very easy to use, just a pain to implement, but I guess it's fine since you only have to do it once ;)

Trinidad Over a year ago

I don't think it's that hard, just some extra ## and \ . Debugging it and tracking compile-time errors can be hard, I think it's better to implement it like List_int and test it first, then make it a "template". Another problem with this approach is that the list type parameter cannot be a pointer, as when generating the procedure names the compiler will not like names containing *, but this can be worked around as I did, by making the pointer implicit.

Zoe - Save the data dump · Accepted Answer · 2019-06-17 06:37:30Z

1

I've used Trinidad's method since I wasn't sure void ** would work and it's pretty nice xD

It works perfectly but it is complicated to avoid circular dependencies (including a header in another that results in "multiple reference") without encumbering too much the interface, so I gave up that approach although I've uploaded it too @SourceForge, then I made everything again, this time with void pointers and it works perfectly ;) No worrying about including a header twice, etc. Just works.

Btw, here's the link, use it at your liking: List - the smart && generic container

In any doubt use the help forums, when I have time I'll document it, but for now I'm using it for my projects.

edited Jun 17, 2019 at 6:37

Zoe - Save the data dump

28.4k22 gold badges130 silver badges163 bronze badges

answered Jan 27, 2011 at 13:30

Alberto

6056 silver badges15 bronze badges

Collectives™ on Stack Overflow

C automatic-expandable array of pointers

2 Answers 2

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related