Thread: Accessing next entry in a queue.

And why couldn't I use what I just wrote (post #75)? I mean, why won't that also work?

Originally Posted by peripatein

And why couldn't I use what I just wrote (post #75)? I mean, why won't that also work?

Am I missing some posts here? Anyway, post #75 looks ok to me. An alternative version, but it's not any "better", just an alternative version:

Code:

void freeSystem(TaxiSystem* system){
    TaxiSystem *tmpdrv;
    TaxiSystem *tmpord;
    while (system->driversQueue){
        tmpdrv = system->driversQueue;
        system->driversQueue = system->driversQueue->next;
        free(tmpdrv);
    }
    while (system->ordersQueue){
        tmpord = system->ordersQueue;
        system->ordersQueue = system->ordersQueue->next;
        free(tmpord);
    }
    free(system);
}

And what vart posted (#74) is obviously also an alternative version, similarly correct, right?

I preferred writing it this way:

Code:

void freeSystem(TaxiSystem* system){
	void* tmp = NULL;
	while (system->driversQueue){
    	tmp = system->driversQueue->next;
    	free(system->driversQueue);
    	system->driversQueue = tmp ;
	}
	while (system->ordersQueue){
		tmp = system->ordersQueue->next;
    	free(system->ordersQueue);
    	system->ordersQueue = tmp ;
	}
	free(system);
}

I would recommend abstracting out the freeing of driversQueue and ordersQueue into separate functions, like so:

Code:

void freeDriver(Driver *drivers) {
    Driver *tmp;
    while (drivers) {
        tmp = drivers->next;
        free(drivers);
        drivers = tmp;
    }
}

void freeOrder(Order *orders) {
    // similar to freeDriver
}

void freeSystem(TaxiSystem* system) {
    if (system) {  // ensure system is non-null
        freeDriver(system->driversQueue);
        freeOrder(system->ordersQueue);
        free(system);
    }
}

This is a better design, and has several benefits:
1. If you need a Driver or Order queue that is not part of a TaxiSystem, you can still free it without re-writing the whlie loop in a separate function.
2. The freeSystem function is easier to read, write and maintain.
3. Separation of concerns. The TaxiSystem should not care how a Driver or Order queue is implemented. This way you can change the underlying implementation of a Driver or Order queue (say a priority queue, FIFO queue, etc) without worrying about changing the TaxiSystem implementation.

NOTE: This sort of abstraction should be used throughout your program. That goes for your add, lookup, remove, etc functions.

If you put the pointers to next first in structures, you can use common code to work with linked lists similar to C++ class inheritance. For example:

Code:

typedef struct node{
    struct node* next;
}Node;

typedef struct driver{
    struct driver* next;
    char name[101];
    int priority;
}Driver;

typedef struct order{
    struct order* next;
    int orderID;
    int isSpecific;
    char specificDriver[101];
}Order;

void freeNodes(Node * nodes) {
    Node *tmp;
    while (nodes) {
        tmp = nodes->next;
        free(nodes);
        nodes = tmp;
    }
}

void freeSystem(TaxiSystem* system) {
    if (system) {  // ensure system is non-null
        freeNodes((Node *)(system->driversQueue));
        freeNodes((Node *)(system->ordersQueue));
        free(system);
    }
}

@rcgldr:
That's not a very safe way to do it:

Originally Posted by C11 6.3.2.3p7

A pointer to an object or incomplete type may be converted to a pointer to a different
object or incomplete type. If the resulting pointer is not correctly aligned for the
pointed-to type, the behavior is undefined.

Pointers can have different sizes and alignments in some systems (uncommon on most desktop environments but still possible). A safer alternative:

Code:

typedef struct node     Node;
struct node {
    Node *next;
};

typedef struct driver    Driver;
struct driver {
    Node node;
    char name[101];
    int priority;
};

typedef struct order    Order;
struct order {
    Node node;
    int orderID;
    int isSpecific;
    char specificDriver[101];
};

void freeNodes(Node *nodes) {
    Node *tmp;
    while (nodes) {
        tmp = nodes->next;
        free(nodes);
        nodes = tmp;
    }
}

void freeSystem(TaxiSystem* system) {
    if (system) {  // ensure system is non-null
        freeNodes((Node *) system->driversQueue);
        freeNodes((Node *) system->ordersQueue);
        free(system);
    }
}

This is allowed since the first member is guaranteed to have the same address as the struct itself:

Originally Posted by C11 6.7.2.1p13

Within a structure object, the non-bit-field members and the units in which bit-fields
reside have addresses that increase in the order in which they are declared. A pointer to a
structure object, suitably converted, points to its initial member (or if that member is a
bit-field, then to the unit in which it resides), and vice versa. There may be unnamed
padding within a structure object, but not at its beginning.

There's a tiny bit more work to build and traverse the list, but at least it's guaranteed to work.

I still don't like that system however. I prefer to use a generic list container:

Code:

typedef struct list    List;
struct list {
    List *next;
    void *data;
};

It costs a few more calls to malloc and free, but it makes a great library and is highly reusable across all my programs. But better still, there exist tons of free libraries out there that already do this, and do it well.