Problem mit einer Stuktur und einem Array

[Austin]

Erst mal hallo.

Ich stehe vor folgendem Problem.

Ich habe eine Struktur die folgende Dinge beinhaltet:

typedef struct{
        int *top;
        int size;                //*Die Struktur ist Vorschrift
        int elemsize;
        void *content;
        }stack_t;

So jetzt habe ich dem element content folgendes zugewiesen:

stack_t *create(int size){
        stack_t *s;              
       s = (stack_t*) malloc(sizeof(stack_t));
        s->size = size;
        s->top = 0;
        s->elemsize = sizeof(size);
        s->content = (stack_t*) malloc(s->size * sizeof(stack_t));
        return s;
}

Wenn ich jetzt versuche in einer Funktion ein Element aus dem Array von content zu belegen mit:

s->content[0] = e;

bekomme ich folgende Fehlermeldung:

Size of type void* is unkown or zero

Ich verstehe das nicht so ganz, ich habe doch dem Element content aus der Struktur ein Array zugewisen oder etwa nicht?

Kann mir vielleicht jemand dabei helfen?

Gruß

Austin

[wraith]

Du legst zwar Speicher an auf den dein void-Pointer content zeigt, aber damit bleibt content weiterhin ein void-Pointer.Und void-Pointer darf du nicht dereferenzieren.
Du mußt den void-Pointer also vorher auf eine Object-Pointer casten, in deinem Fall ist das ein stack_t-Pointer.

((stack_t*)s->content)[0] = e; /* ich nehme doch an e ist eine stack_t Instanz */

Du belegst elemsize mit sizeof size, was 4 ist, aber sollte da nicht sizeof(stack_t) stehen, also die Größe eines Eintrages?

[Austin]

Du legst zwar Speicher an auf den dein void-Pointer content zeigt, aber damit bleibt content weiterhin ein void-Pointer.Und void-Pointer darf du nicht dereferenzieren.
Du mußt den void-Pointer also vorher auf eine Object-Pointer casten, in deinem Fall ist das ein stack_t-Pointer.

((stack_t*)s->content)[0] = e; /* ich nehme doch an e ist eine stack_t Instanz */

Du belegst elemsize mit sizeof size, was 4 ist, aber sollte da nicht sizeof(stack_t) stehen, also die Größe eines Eintrages?

Hi erst mal danke für deine Hilfe.
Das mit sizeof(stack_t) da könntest du recht haben ich war mir dabei nicht sicher.

Also die void Fehlermeldung ist mit dem Cast so wie du ihn beschreibst endlich weg.

Jetzt habe ich eine Illegal structer operation.

Ich schätze das liegt an der übergabe von e das sieht wie folgt jetzt aus nur mal ein ausschnitt:

char push(stack_t *s, void *e){
 ((stack_t*)s->content)[s->top] = e;
             s->top++;
}

ich haben dann mir gedacht was mit dem content geht, geht auch mit dem e und habe das so geschrieben:
[code]

char push(stack_t *s, void *e){
 ((stack_t*)s->content)[s->top] = ((stack_t*)e);
             s->top++;
}

Ich schätze ich habe mir da wieder was falsches gedacht oder??

Naja bin halt noch anfänger .

Gruß

Austin

[wraith]

Hast du für die create und push Funktion konkrete Prototypen vorgegeben, und sehen die so aus, wie du sie gepostet hast?

Deine zweite push-Variante ist schon fast in Ordnung, aber du hast jetzt links ein stack_t Objekt stehen, und versuchst ein stack_t-Pointer zu zuweisen.Du müßtest also rechts noch einmal dereferenzieren.
Außerdem ist top ein Pointer und müßte auch noch dereferenziert werden.

Die ganze Herangehenweise ist wahrscheinlich eher so gemeint.
Jetzt muß man nicht ständig auf das gespeicherte Element casten, und elemsize bekommt eine Bedeutung.
Einen stack_t für stack_t-Objekte würdest du dann mit create(10,sizeof(stack_t)); erstellen.

....

stack_t *create(int maxlength,int elemsize)
{
    stack_t *s;
    s = malloc(sizeof *s);
    s->size = maxlength;
    s->top = malloc(sizeof *s->top);
    *s->top = 0;
    s->elemsize = elemsize;
    s->content = malloc(s->size * s->elemsize);
    return s;
}

void push(stack_t *s,void *e)
{
    memcpy((char*)s->content + s->elemsize * *s->top,e,s->elemsize);
    ++*s->top;
}

int main()
{
    stack_t *s;
    int i;

    /* Einen Stack für 10 int erstellen */
    s = create(10,sizeof(int));

    /* 10 int auf den Stack pushen */
    for(i = 0;i < s->size;i++)
        push(s,&i);

    for(i = 0;i < s->size;i++)
        printf("%d\n",*((int*)s->content + i));

    return 0;
}

Bei der ganzen Sache stört mich hier eigentlich nur das top ein int-Pointer ist, und nicht ein einfacher int.

[Austin]

HI

Ja ich würde das schon auch gerne anders schreiben dürfen aber ich darf leider das nur mit den gegebenen Funktionen machen.

Und die dürfen nicht verändert werden das ist Teil der Aufgabe hier mal die Header Datei:

typedef struct{    
 int top;
 int size;
 int elemsize;
 void **content;
 } stack_t;

stack_t *create(int size);  
char isEmpty(stack_t *s);
char push(stack_t *s, void *e);
char pop(stack_t *s);
void *top(stack_t *s);
char destroy(stack_t *s);

Das sind meine Vorgaben da kann ich leider nix machen.
Aber hier darf ich das ja mal sagen, also ich finde man könnte vieles davon einfacher Lösen.

Aber wenn das der Prof so vorgibt muß ich mal daran halten.

Gruß

Austin