I was wondering if it would be possible to create a queue data structure in C that can enqueue elements based on the type user specifies at the point where he uses it .
Something like templates in C++ or Arraylists in C#.
This Question has been solved and asker verified All Experts Exchange premium technology solutions are available to subscription members.
Experts Exchange has been collecting answers to technology questions since 1996…3 million and counting! If you have a question, chances are we already have your answer.
If you can't find the exact answer you're looking for, ask our exclusive community of 50,000 experts. You’ll get a personalized answer from a trusted professional.
Thousands of free tech tips, tricks, how-to’s and tutorials are available in our peer reviewed articles section. See for yourself how smart our experts are, no login required.
Save solutions to your questions, answers you’ve discovered through searching plus helpful articles in your personal knowledgebase for easy future access.
Access the answers to your technology questions today.
30-day free trial. Register in 60 seconds.
Members of the expert community talk about why the experience at Experts Exchange is different than what you will find anywhere else.
Try it out and discover for yourself.
30-day free trial. Register in 60 seconds.
Join the community of experts here and help other tech pros by answering question in your area of expertise. You can earn FREE access to all Experts Exchange's premium features and resources.
There are a few ways to achieve that but none is as good as what C++ offers. At the very least you need to know what all types of elements would you like to enqueue
1.
enum queue_types {
int = 1,
char,
...
};
struct node {
queue_types type;
void * data;
}
You can now create a queue of struct node type. The type field identifies the type of data that void * points to.
2.
enum queue_types {
int = 1,
char,
...
};
struct my_type_int {
enum queue_type type;
int data;
};
struct my_type_float {
enum queue_type type;
float data;
};
...
Create a queue of void * ... each void * points to a my_type_* kind of data. Cast void * to any my_type_* and read the type field. That would give you the type of data.
3.
Create a union of types
...
There might be others but yu get the idea - you need to know the types to enqueue in advance
Define each element in the queue to hold a void pointer as a member. When adding an element, use malloc() to assign the correct space for the data type, then cast it into the void pointer. Use free() to clean up afterwards.
You need to make sure you use the sizeof() operator to correctly assign memory for your data type.
Try building a void* queue and assigning integers to it (ie construct with void ptrs, assign 4 bytes, cast the integer into it). When you have that working, you can easily extend the code to support ANY data type.
example:
int a; // temporary integer
void *vptr; // void pointer (could point to memory / whatever)
a = *(int*) vptr; // assigns the value of *vptr (the content of the memory pointed at) to a, by "assuming" vptr points to an integer
I came across a simple code example on this page http://142.132.30.225/prog
How about using a library which does have such a thing?
http://library.gnome.org/d
Regards
Friedrich
Hi Novice,
Any generic approach in C will require some casting. The trick is to minimise it as far as possible. I also prefer to avoid void * as far as possible too.The way I would do it would be something like:
Queue.h
typedef struct QueueEntry {
QueueEntry * next;
...
} QueueEntry;
YourSource.h or .c
#include "Queue.h"
typedef struct YourQueueEntry {
// Must be at the start of the struct so we can cast from a QueueEntry to a YourQueueEntry.
QueueEntry queueNode;
// Payload of the queue entry.
YourStructure yourData;
} YourQueueEntry;
YourSource.
...
// Make a new queue entry.
YourQueueEntry *newEntry = (YourQueueEntry*) malloc (sizeof(YourQueueEntry));
.
// Add it to the queue.
AddToQueue (&newEntry.queueNode);
...
// Grab from queue.
YourQueueEntry * nextEntry = (YourQueueEntry*)GetNextQu
.
In this way, all the management of the queue can be done using QueueEntry structures inside Queue.c.
Paul
Good points FentonEng. All allocation must done outside the Queue code and therefore obviously all freeing too, but in my opinion isn't such a bad thing. There's certainly no question as to who is responsible for the memory.
The sweet side of this technique is that the Queue code works only with Queue structures. No baggage at all. As spartan and functional as they come. :)
The main downside is that you have to expose the structure of the Queue element to the world which makes it tempting to follow the links from outside the Queue module.
You can use this technique with almost any linked structure.
Paul
Business Accounts
Answer for Membership
by: FentonEngPosted on 2008-09-21 at 16:15:05ID: 22536400
void* pointers perhaps?
That would be a valid way to emulate a template. You would need to keep a close eye on the size of the elements and the size of the entire queue structure in case you stepped into memory not allocated to the process.
Just to clarify:
Do you want a queue that can hold multiple types (ie insert anything into anything)
Or a queue that deals with a single type, but ANY type (ie insert something specific into a specific queue)