数据类型独立堆栈 - C编程

Question

Often stacks in C are dependent upon datatype used to declare them. For example,

int arr[5]; //creates an integer array of size 5 for stack use
char arr[5]; //creates a character array of size 5 for stack use

are both limited to holding integer and character datatypes respectively and presumes that the programmer knows what data is generated during the runtime. What if I want a stack which can hold any datatype?

I initially thought of implementing it as a union, but the approach is not only difficult but also flawed. Any other suggestions?

Answer 1

I would use a structure like this:

struct THolder
{
   int dataType; // this is a value representing the type
   void *val; // this is the value 
};

Then use an array of THolder to store your values.

Answer 2

This is really just a variant of Pablo Santa Cruz' answer, but I think it looks neater:

typedef enum { integer, real, other } type_t;

typedef struct {
    type_t type;
    union {
        int normal_int;     /* valid when type == integer */
        double large_float; /* valid when type == real */
        void * other;       /* valid when type == other */
    } content;
} stack_data_t;

You still need to use some way to explicitly set the type of data stored in each element, there is no easy way around that.

You could look into preprocessor magic relying on the compiler-dependent typeof keyword to do that automagically, but that will probably not do anything but ruin the portability.

Answer 3

Some people have suggested a void* member. In addition to that solution I'd like to offer an alternative (assuming your stack is a linked list of heap-allocated structures):

struct stack_node
{
   struct stack_node *next;
   char data[];
};

The data[] is a C99 construct. data must be the last member; this takes advantage of the fact that we can stuff arbitrary quantities after the address of the struct. If you're using non-C99 compiler you might have to do some sketchy trick like declare it as data[0] .

Then you can do something like this:

struct stack_node*
allocate_stack_node(size_t extra_size)
{
   return malloc(sizeof(struct stack_node) + extra_size);
}

/* In some other function... */

struct stack_node *ptr = allocate_stack_node(sizeof(int));

int *p = (int*)ptr->data;

If this looks ugly and hacky, it is... But the advantage here is that you still get the generic goodness without introducing more indirection (thus slightly quicker access times for ptr->data than if it were void* pointing to a different location from the structure.)

I'd also like to point out that the code sample I give may have problems if your machine happens to have different alignment requirements for int than char . This is meant as an illustrative example; YMMV.

Answer 4

I created an library that works for any data type:

    List new_list(int,int);

creates new list eg:

    List list=new_list(TYPE_INT,sizeof(int));
    //This will create an list of integers
    Error append(List*,void*);

appends an element to the list. *Append accpts two pointers as an argument, if you want to store pointer to the list don't pass the pointer by pointer

eg:

    //using the int list from above

      int a=5;
      Error err;
      err=append(&list,&a)

      //for an list of pointers
      List listptr=new_list(TYPE_CUSTOM,sizeof(int*));
      int num=7;
      int *ptr=#

      append(&listptr,ptr);


      //for list of structs
      struct Foo
      {
        int num;
        float *ptr;
      };

      List list=new_list(TYPE_CUSTOM,sizeof(struct Foo));
      struct Foo x;
      x.num=9;
      x.ptr=NULL;

      append(&list,&x);

Error get(List*,int);

Gets data at index specified. When called list's current poiter will point to the data.

eg:

    List list=new_list(TYPE_INT,sizeof(int));

    int i;
    for(i=1;i<=10;i++)
      append(&list,&i);

    //This will print the element at index 2
    get(&list,2);
    printf("%d",*(int*)list.current);

Error pop(List*,int);

Pops and element from the specified index

eg:

      List list=new_list(TYPE_INT,sizeof(int));

      int i;
      for(i=1;i<=10;i++)
        append(&list,&i);

      //element in the index 2 will be deleted, 
      //the current pointer will point to a location that has a copy of the data  

      pop(&list,2);
      printf("%d",*(int*)list.current);

      //To use the list as stack, pop at index list.len-1
      pop(&list,list.len-1);

      //To use the list as queue, pop at index 0
      pop(&list,0);

Error merge(List ,List);

Merges two list of same type. If types are different will return a error message in the Error object it returns;

eg:

     //Merge two elements of type int
     //List 2 will come after list 1
     Error err;
     err=merge(&list1,&list2);
    Iterator get_iterator(List*);

Get an iterator to an list. when initialized will have a pointer to the first element of the list.

eg:

    Iterator ite=get_iterator(&list);
    Error next(Iterator*);

Get the next element of the list.

eg:

//How to iterate an list of integers

      Iterator itr;
      for(itr=get_iterator(&list);  ite.content!=NULL;  next(ite))
        printf("%d",*(int*)ite.content);

https://github.com/malayh/C-List

Answer 5

You could use macros and a "container" type to reduce "type" from being per-element, to whole-container. (C99 code below)

#define GENERIC_STACK(name, type, typeid, elements) \
  struct name##_stack { \
    unsigned int TypeID; \
    type Data[elements]; \
  } name = { .TypeID = typeid }

Of course, your "TypeID" would have to allow every possible agreed-upon type you expect; might be a problem if you intend to use whole structs or other user-defined types.

I realize having a uniquely named struct type for every variable is odd and probably not useful... oops.