# [c] stapel(stack)



## thehasso (19. April 2008)

Hallo,

Ich hab eine Aufgabe :

Entwerfen Sie ein Programm (Datenentwurf und Modulentwurf als Struktogramm) zum
Hinzufügen von beliebig vielen Elementen in einen Stapel (stack) nach Wunsch.
Als Nutzdaten sollen jeweils der Name, das Alter und das Gehalt einer Person dienen.
Sehen Sie für jedes Element des Stapels einen passenden Strukturtyp vor.
Dieses Hinzufügen soll ein separates Modul: input übernehmen.
Anschließend sollen alle Elemente des Stapels gelesen, damit ausgegeben und gelöscht
werden. Dies soll ein separates Modul: output übernehmen.

Ich hab mich in Wikipedia schlau gemacht , und hab das Prinzip LIFO verstanden
(last input first out).

Ich möchte kein Struktogramm machen sondern es programmieren..
Kann mir jemand irgendwelche Tipps geben wie man solch ein Programm am besten vorgeht. 


Gruß


----------



## devDevil (20. April 2008)

Struct für Node/Item(mit zeiger auf nächstes item), Speicher immer das letzte Item und das erste ... ist dann einfach zum durchlaufen ... beim einfügen einfach zeiger fürs letzte item auf ein neues item setzen und next des items auf altes letzes item setzen ... schon fertig.


----------



## thehasso (20. April 2008)

Sprich ich muss mich mit Zeiger und pointer auseinandersetzen und struct um die aufgabe zu lösen? oder gibt es noch etwas was ich wissen müsste? (programmiermäßig)


gruß


----------



## Teambeta (20. April 2008)

Per C++ könntest du das mit Vectoren, Stack, Maps, etc. lösen.

C mäßig müsstest du dich mit dem was du aufgelistet hast beschäftigen.

Viel Spaß und Erfolg .


----------



## thehasso (29. April 2008)

Hallo, 

Eine verständnisfrage zu zwar, müssen die Nutzdaten Name, das Alter und das Gehalt einer Person jedes mal in einen neuen Sackgespeichert werden.....


Mit struct hab ich mich auseinandergesetzt und habe das programm so programmiert:



```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>


#define MAX 30


struct adres {char vorname[MAX]; char name[MAX]; int alter; float gehalt;} adresse; // nicht ( ; ) vergessen!


void output(struct adres * struct_ptr) // Ausgabe der Datensätze!

{

printf("\n\nSie gaben ein:\n\n");

printf("Vorname......%s:",struct_ptr->vorname); 

printf("Nachname.....%s:",struct_ptr->name); 

printf("Alter........%i:",struct_ptr->alter); 

printf("Gehalt.......%f:",struct_ptr->gehalt); 

}

//void input(adres * struct_eingabe)



int main(void)

{


printf("\nVorname :");

printf("\nEingabe:"); fgets(adresse.vorname, MAX, stdin);


printf("\n\nNachname :");

printf("\nEingabe:"); fgets(adresse.name, MAX, stdin);

printf("\n\nAlter :");

printf("\nEingabe:"); scanf("%i",&adresse.alter, MAX, stdin);


printf("\n\nGehalt :");

printf("\nEingabe:"); scanf("%f",&adresse.gehalt, MAX, stdin);


output(&adresse);


return EXIT_SUCCESS;

getchar();

}
```

Jedoch ohne stack und next..usw.. Ich verstehe nicht so ganz wie Hinzufügen von beliebig vielen Elementen in einen Stapel (stack) nach Wunsch funktioniert.


über eine etwas ausführliche antwort wär ich sehr dankbar..


----------



## devDevil (30. April 2008)

Naja du muss halt immer dir nen Zeiger aufs nächste Element speichern.

So hab es dir mal Beispielhaft implementiert. ... 10min brauchst de höchstens!


```
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX 30
```
 Dein max für die max. Stringlänge. Das habe ich aus deinem Code übernommen. Das ganze mit Variabler Stringlänge zu realisieren ist mir jetzt zu viel arbeit gewesen!


```
typedef struct node_t_ 
{
    char prename[MAX]; 
    char name[MAX]; 
    unsigned char age; 
    float bank;
    struct node_t_* next; // save pointer to next item in stack
} node_t;
```
 ... Das ist die Struktur. Sind ein par Sachen verändert.

Die Ausgabefunktion:

```
void output_stack(const node_t* ptr_first)
{
    // step through items
    const node_t* temp = ptr_first;
    // until end of stack
    while (temp != NULL)
    {
        printf("Vorname......%s:", temp->prename); 
        printf("Nachname.....%s:", temp->name); 
        printf("Alter........%i:", temp->age); 
        printf("Gehalt.......%f:", temp->bank); 
        temp = temp->next;
    }
}
```

Die Funktion um ein Item anzufügen

```
void push_stack(const node_t* ptr_data, node_t** ptr_first)
{
    // create new node
    node_t* ptr_new = (node_t*)malloc(sizeof(node_t));
    // copy data
    strcpy(ptr_new->prename, ptr_data->prename);
    strcpy(ptr_new->name, ptr_data->name);
    ptr_new->age = ptr_data->age;
    ptr_new->bank = ptr_data->bank;

    // push item into current stack (LI-FO)
    ptr_new->next = *ptr_first;
    *ptr_first = ptr_new;
}
```

Die Funktion um das erste Item wieder zu löschen (vgl. *L*ast *i*n - *F*irst *o*ut-Prinzip)

```
node_t pop_stack(node_t** ptr_first)
{
    // temporary copy of first item
    node_t copy;
    memcpy(&copy, *ptr_first, sizeof(node_t));

    // temporary pointer to next item
    node_t* ptr_next = (*ptr_first)->next;
    // delete first item (LI-FO)
    free(*ptr_first);
    // set following item to be first item 
    *ptr_first = ptr_next;

    return copy;
}
```

Funktion zum Aufräumen des Stacks

```
void clear_stack(node_t** ptr_first)
{
    // temporary note (helper)
    node_t* temp = *ptr_first;
    while (temp != NULL)
    {
        // set next node to be first
        *ptr_first = temp->next;
        // delete old first item
        free(temp);
        // helper to first item
        temp = *ptr_first;
    }
    // set list to be freed.
    *ptr_first = NULL;
}
```

Und zu guter letzt ein Beispielprogramm:

```
int main()
{
    // need for stack
    node_t* ptr_first = NULL;

    // insert items
    // first
    node_t item = { "Muster", "Mustermann", 45, 0.5f, NULL };
    push_stack(&item, &ptr_first);
    // second
    item.age = 100;
    push_stack(&item, &ptr_first);
        
    // output items
    output_stack(ptr_first);

    // delete last inserted item
    pop_stack(&ptr_first);
    
    // insert third item
    strcpy(item.name, "Tester");
    push_stack(&item, &ptr_first);

    // output items
    output_stack(ptr_first);

    // free stack
    clear_stack(&ptr_first);

    // wait for userinput 
    getchar();
    return EXIT_SUCCESS;
}
```
.

So das war es auch schon  Viel Spaß damit und kannst gerne nachfragen, wenn du was nicht verstanen hast.


----------

