Stack Queue FRAGEN

seoman

Hallo,

also ich soll ein printjob modul machen, wo ich einen struckt SPJob habe

typedef struct SPJob {
long pid;
char szText[laeng];
}SPJob;

in dem printjob file soll ich folgende funktionen erstellen
SPJob *createJob(unsigned int, char *); //creates Job void setText(SPJob *, char /*sets text as new String*/ void printText(SPJob *); /*prints text on stdio*/ void removeJob(SPJob /*deletes Job and Textstring */

und ich soll ein file machen mit einem einem Queue struct mit folgenden funktionen: aber wie soll der struct aussehen was speichere ich da ab?

SQueue *createQueue(unsigned int); /*creates queue */ int push(SQueue *, unsigned int, char *); /*ctreates && pushes printjob*/ SPJob pop(SQueue *); /*pos && deletes*/
void printJobs(SQueue *); /*prints all jobs in queue*/
void dispose(SQueue *); /*removes && deletes all jobs in queue and deletes queue*/

und wozu brauchen ich sztext wenn ich schon beim jobcreate den text speichern kann. Kann mir jemand vielleicht erklären wie der zusammenhang ist und wo ich welche funktionen aufrufe? Ich verstehe den zusammenhang nicht. Ich weiß das was mit OOP zu tun hat, weil wir ja gerade damit beginnen, aber ich durchschaue es nocht nicht ganz.

hi,
eine queue kann man z.b. mit verketteten listen aufbauen, hier haste mal ein beispiel:

// nt_lists.cpp : Definiert den Einstiegspunkt für die Konsolenanwendung.
//

#include <stdio.h>

#define C_OFFSET(t,f) ((char*)&(((t*)0)->f))
#define C_BASE(a,t,f) ((t*)((char*)(a)-C_OFFSET(t,f)))

typedef struct _NT_LIST_ENTRY 
{
   struct _NT_LIST_ENTRY *Flink;
   struct _NT_LIST_ENTRY *Blink;
} NT_LIST_ENTRY;

#define InitializeListHead(ListHead) (\
    (ListHead)->Flink = (ListHead)->Blink = (ListHead))

#define IsListEmpty(ListHead) \
    ((ListHead)->Flink == (ListHead))

#define RemoveHeadList(ListHead) \
    (ListHead)->Flink;\
    {RemoveEntryList((ListHead)->Flink)}

#define RemoveTailList(ListHead) \
    (ListHead)->Blink;\
    {RemoveEntryList((ListHead)->Blink)}

#define RemoveEntryList(Entry) {\
    NT_LIST_ENTRY *_EX_Blink;\
    NT_LIST_ENTRY *_EX_Flink;\
    _EX_Flink = (Entry)->Flink;\
    _EX_Blink = (Entry)->Blink;\
    _EX_Blink->Flink = _EX_Flink;\
    _EX_Flink->Blink = _EX_Blink;\
    }

#define InsertTailList(ListHead,Entry) {\
    NT_LIST_ENTRY *_EX_Blink;\
    NT_LIST_ENTRY *_EX_ListHead;\
    _EX_ListHead = (ListHead);\
    _EX_Blink = _EX_ListHead->Blink;\
    (Entry)->Flink = _EX_ListHead;\
    (Entry)->Blink = _EX_Blink;\
    _EX_Blink->Flink = (Entry);\
    _EX_ListHead->Blink = (Entry);\
    }

#define InsertHeadList(ListHead,Entry) {\
    NT_LIST_ENTRY *_EX_Flink;\
    NT_LIST_ENTRY *_EX_ListHead;\
    _EX_ListHead = (ListHead);\
    _EX_Flink = _EX_ListHead->Flink;\
    (Entry)->Flink = _EX_Flink;\
    (Entry)->Blink = _EX_ListHead;\
    _EX_Flink->Blink = (Entry);\
    _EX_ListHead->Flink = (Entry);\
    }

////////////////////////////////////////////////////////////////////////

typedef struct _testlist
{
    int lala;
    char buh;
    long blubb;
    NT_LIST_ENTRY list;
    char array[8];
} TESTLIST;

/*
int main()
{
    TESTLIST t;
    TESTLIST *tp1 = &t;
    TESTLIST *tp2 = C_BASE (&t.blubb, TESTLIST, blubb);
    if (tp1 == tp2)
        printf ("Bingo");
    Sleep(INFINITE);
}
*/

int main ()
{
    NT_LIST_ENTRY list1;

    TESTLIST tl[10];
    int s;

    InitializeListHead (&list1);

    for (s=0; s<10; s++)
        InsertHeadList (&list1, &(tl[s].list));	

    while (1)
    {
        NT_LIST_ENTRY *l;
        if (IsListEmpty(&list1))
            break;
        l = RemoveHeadList (&list1);
        printf ("%p\n", l);
    }

    printf ("--------------------------\n");

    for (s=0; s<10; s++)
        InsertHeadList (&list1, &(tl[s].list));	

    while (1)
    {
        NT_LIST_ENTRY *l;
        if (IsListEmpty(&list1))
            break;
        l = RemoveTailList (&list1);
        printf ("%p\n", l);
    }

	for (;;); //Sleep (INFINITE);
}

füg einfach in deine struct SPJob einen member des typs NT_LIST_ENTRY ein, lege dir einen NT_LIST_ENTRY als listenkopf an (siehe beispiel) und schon sind deine structs 'queue-fähig'