C / C++ / MFC

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

struct JobCodeNode
{
    // these should be at the first 8 bytes, so you can manipulate them without 
    // typecasting them to the actual type
    JobCodeNode* pNext;
    JobCodeNode* pPrev; // leave this out if you don't need a bi-directional list

    JobCode* pNode;
};

struct LinkedList
{
    void* pStartNode;
    void* pCurrentNode; // more difficult to implement, but certainly speeds up things
};

// functions that traverse the list
LinkedList InitLList(void* pStart)
{
    LinkedList LList;
    LList->pStartNode = pStart;
    LList->pCurrentNode = pStart;

    // you can initialize the start node too
    ((int*)pStart) = NULL; // next node
    ((int*)(pStart + 4)) = NULL; // prev node

    return LList;
}

// other traversing routines

/* myinclude.h */
#define LISTHANDLE (void*);
LISTHANDLE List_Create(size_t record_size);
size_t List_Size(LISTHANDLE hList);
int List_Append(LISTHANDLE hList, void* pRecord);
int List_ReadNext(LISTHANDLE hList, void* pRecord);
int List_Insert(LISTHANDLE hList, void* pRecord);
int List_Sort(int (*callback)(void*,void*));
/*
 etc...
*/
/* mysource.c */
#ifndef BYTE
#define BYTE unsigned char
#endif
typedef struct st_NodeHeader
{
    struct st_NodeHeader* pNext;
} NODE_HEADER;

typedef struct st_Header
{
    size_t nRecSize;
    NODE_HEADER* pHead;
    NODE_HEADER* pTail;
    NODE_HEADER* pCurrent;
} HEADER;

LISTHANDLE List_Create(size_t record_size)
{
    HEADER* pHeader = (HEADER*)malloc(sizeof(HEADER));
    if( pHeader )
    {
        memset(pHeader,0,sizeof(HEADER);
        pHeader->nRecSize = record_size;
    }
    return(pHeader);
};

int List_Insert(LISTHANDLE hList, void* pRecord)
{
    if( hList && pRecord )
    {
        HEADER* pHeader = (HEADER*)hList;
        size_t nNodeSize = sizeof(NODE_HEADER) + pHeader->nRecSize;
        NODE_HEADER* pNode = (NODE_HEADER*)malloc(nNodeSize);
        if( pNode )
        {
            BYTE* pRec = ((BYTE*)pNode) + sizeof(NODE_HEADER);
            pNode->pNext = (NODE_HEADER*)0;
            memcpy(pRec,pRecord,pHeader->nRecSize);
            /*
            Add node to list like normal
            .......
            */
            return(1);
        }
    }
    return(0);
}

int List_ReadNext(LISTHANDLE hList, void* pRecord)
{
    if( hList && pRecord )
    {
        HEADER* pHeader = (HEADER*)hList;
        if( pHeader->pCurrent )
        {
            BYTE* pRec = ((BYTE*)pNode) + sizeof(NODE_HEADER);
            memcpy(pRecord,pRec,pHeader->nRecSize);
            pHeader->pCurrent = pHeader->pCurrent->pNext;
            return(1);
        }
    }
    return(0);
}