如何在c或c ++中创建异构链接列表

Question

A link list that can hold float,integer,character,etc data and algorithm should be well and not very complex

I thought of creating a structure with void pointer that will point to subsequent nodes. but problem is that i cannot use templates with structure.

coming down to c, i have to test each character entered by user to test whether it is integer , float or character or not.then we can proceed further

please suggest an efficient algorithm/code

Answer 1

If you want to do this yourself you'll basically want to create an array or linked list of elements that encode both the data and the type of data. You could use a struct that includes a type indicator and a union of the various types that you want to handle, and the create an array or linked list of that struct:

typedef struct {
    int type_indicator;
    union {
        float f;
        int i;
        double d;
        void *p;
        char c;
    }
} generic_item;

generic_item generic_array[10];

I'll leave it to you to come up with an appropriate enumeration for the type indicator and to add a function pointer for your algorithm. If you want a linked list instead of an array, you'll obviously also need to add a generic_item *next pointer.

I haven't looked into the boost options that other answers link to, but I'd probably look there first before trying to roll my own solution.

Answer 2

Using boost::variant or boost::any . Depends on your needs.

Answer 3

NOTE: This is a purely C answer.

This data structure is what I would start out with:

typedef struct heterogeneous_list
{
    enum { CHAR, STRING, FLOAT, INT } type;
    void *item;
    struct heterogeneous_list *next;
}

When I got the item from the user, I would store it in the list (assuming current points to the end of the list):

current->next = malloc(sizeof(heterogeneous_list));
case (/* whether the user entered a char, string, float, or int */
{
    case /* char */:
        current->next.item = malloc(sizeof(char));
        current->next.type = CHAR;
        current->next.next = NULL;
        break;
/* and so forth, for string, int, and float */
}
current = current->next;

When iterating through the list, it is easy now to process what is in the list based on type. The following code assumes current is the current item in the list being looked at in an iteration (a for-loop going through the list):

char currentItemChar;
char * currentItemString;
float currentItemFloat;
int currentItemInt;

case (current->type)
{
    case CHAR:
        currentItemChar = *((char*) current->item);
        // process a character
        break;
    case STRING:
        currentItemString = (char*) current->item;
        // process a string
        break;
    case FLOAT: 
        currentItemFloat = *((float*) current->item);
        // process a float
        break;
    .
    .
    .
};

That's what I would do.

Answer 4

http://www.boost.org/doc/libs/1_48_0/doc/html/variant.html

(which of course also mentions C/C++ unions before explaining what boost variants give you over this)

Answer 5

A heterogeneous linked list can be created by using a void * as a pointer to a data item:

struct Node
{
    Node * previous;
    Node * next;
    void * p_data;
};

Before implementing a heterogenous container, one might ask if the design can be changed to use homegeneous containers instead.

Answer 6

You could do this kind of things using - as you mentioned - some void pointers in connection with some more or less tricky macros.

You could define a struct (or a class) containing three pointers: next, prev (for the next and the previous list element), and some kind of void* data . You could moreover store the type for each list entry (which could be realized by an enum or something equivalent).

Moreover, you could define a macro that - given a list item - retrieves the data and automatically cast it into a given type:

#define get_list_item(item, type) *(type*)(((item)->data))