Strukturen um Info von Angestellten zu speichern

julia90

Kann jemand mir helfen meinen Code vervollständigen? Der Code funktioniert, wie ich es möchte. Ich muss aber jetzt bei der search_employee Funktion, so implementiert, dass der gesuchte Eintrag mit seinem Vorgänger vertauscht werden. Die search_employee Funktion funktioniert wie sein Name sagt, sie sucht nach dem Namen eines Angestellten in der Liste und wenn ein entsprechender Eintrag gefunden wurde, dann werden die Personalnummer und das Einkommen des Angestellten angezeigt. Außerdem ich darf nur ein einfach verketteten Liste erstellen.

Vielen Dank für die Hilfe.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
struct s_emplist{
    char forename[64];
    char surname[64];
    unsigned int persnr;
    float salary;
    struct s_emplist *next;
};
typedef struct s_emplist *t_emplist;

t_emplist new_employee(t_emplist emplist, t_emplist elp){
    elp->next = emplist;
    emplist = elp;
    return emplist;
}

void search_employee(t_emplist emplist, char *forename, char *surname){
    t_emplist p=emplist, q, r;
    while(p->next!=NULL && strcmp(p->next->forename, forename)!=0 && strcmp(p->next->surname, surname)==0) p = p->next;
    if(p->next!=NULL && strcmp(p->next->forename, forename)==0 && strcmp(p->next->surname, surname)==0){
        printf("\nPersNr.: %u\n", p->next->persnr);
        printf("Einkommen: %.2f\n", p->next->salary);
    }
    return;
}

void printlist(t_emplist elp){
    printf("\n***********************************\n");
    while (elp!=NULL){
        printf("Vorname: %s\n", elp->forename);
        printf("Nachname: %s\n", elp->surname);
        printf("PersNr.: %u\n", elp->persnr);
        printf("Einkommen: %.2f\n", elp->salary);
        elp = elp->next;
    }
    printf("\n***********************************\n");
}

int main(){
    t_emplist emplist=NULL, elp;
    char forename[64], surname[64];
    unsigned int op;
    do{
        printf("\n Waehlen Sie einen Menuepunkt: \n");
        printf("\n 1) Neuer Angestellter");
        printf("\n 2) Suche Angestellten");
        printf("\n 3) Liste anzeigen");
        printf("\n 4) STOP \n");
        scanf(" %u", &op);
        switch(op){
            case 1:
                elp = (t_emplist)malloc(sizeof(*elp));
                printf("\n Vorname: "); scanf(" %63s", elp->forename);
                printf("\n Nachname: "); scanf(" %63s", elp->surname);
                printf("\n Personalnummer: "); scanf(" %u", &(elp->persnr));
                printf("\n Einkommen: "); scanf(" %f", &(elp->salary));
                emplist = new_employee(emplist, elp);
                break;
            case 2:
                printf("\n Vorname: "); scanf("%63s", forename);
                printf("\n Nachname: "); scanf("%63s", surname);
                search_employee(emplist, forename, surname);
                break;
            case 3:
                printlist(emplist);
                break;
        }
    }while(op != 4);
    return 0;
}

SeppJ

Hast du mal einen Angestellten gesucht, der zufällig am Ende deiner Liste ist?

Ansonsten: Wo genau ist das Problem? Du hast verkettete Listen zumindest so ungefähr verstanden. Zwei Elemente zu vertauschen sollte doch einfach für dich sein. Offensichtlich musst du dir während der Suche irgendwie den Vorgänger merken, da der gefundene Eintrag selber keinen Verweis mehr auf den Vorgänger hat.

Weitere Kritik:

Deine Funktionen tun zu viel. search_employee sollte genau eine Sache tun, nämlich etwas Suchen. Nichts Ausgeben. Nichts Tauschen. Funktionen tun immer genau eine Sache und diese richtig.
Dein Code ist schrecklich zu lesen wegen der komischen Bezeichner. Eigentlich sogar gar nicht. Ich habe jetzt daher auch gar nicht alles geprüft. Lass die dummen Präfixe weg, was sollen die überhaupt anzeigen? Und gönn deinen Bezeichnern mehr Buchstaben! Es ist nicht 1950, wo der gesamte Quelltext in 2000 Bytes passen muss. Programmieren ist kein Wettbewerb darin, sich möglichst kurz und unverständlich auszudrücken, sondern das Gegenteil! Dein Programm sollte sich mit deinen Bezeichnern am Ende fast so lesen wie ein normaler englischer Text!
Fließkommazahlen sind der wohl am wenigsten gut geeignete Typ für Geldbeträge. Fließkommazahlen sind toll um kontinuierliche Berechnungen im diskreten Computer zu emulieren, auf Kosten, dass nicht alles ganz exakt berechnet wird. Geld hingegen ist eine diskrete Größe dar, und den meisten Menschen sind exakte Ergebnisse beim Geld extrem wichtig! Um als Anfänger nicht völlig überfordert zu werden mit der gar nicht so leichten Modellierung von Geld, empfiehlt es sich, einfach eine Ganzzahl (long int) zu benutzen, und diese als einen Cent (oder besser noch Zehntelcent oder kleiner) anzusehen.

Wutz

@julia90 sagte in Strukturen um Info von Angestellten zu speichern:

 t_emplist new_employee(t_emplist emplist, t_emplist elp){
    elp->next = emplist;
    emplist = elp;
    return emplist;
}

void search_employee(t_emplist emplist, char *forename, char *surname){
    t_emplist p=emplist, q, r;
    while(p->next!=NULL && strcmp(p->next->forename, forename)!=0 && strcmp(p->next->surname, surname)==0) p = p->next;
    if(p->next!=NULL && strcmp(p->next->forename, forename)==0 && strcmp(p->next->surname, surname)==0){
        printf("\nPersNr.: %u\n", p->next->persnr);
        printf("Einkommen: %.2f\n", p->next->salary);
    }
    return;
}

Bevor du mit deinem Code weitermachst, mache ihn wenigstens annähernd fehlerfrei, damit du deine Fehler nicht mitschleifst;
du hast den Sinn von verk.Listen nicht verstanden (obwohl sie natürlich gar keinen Sinn und Zweck haben sondern nur bei Buchautoren,Professoren und Tutorialschreiberlingen - d.h. in der Praxis nie - vorkommen).

wob

@Wutz sagte in Strukturen um Info von Angestellten zu speichern:

d.h. in der Praxis nie

Never say never... Habe das in hochperformantem (!) Code schon gesehen. Da wurde allerdings nicht nur ein next/prev-Pointer und die Nutzdaten, sondern auch noch ein Mutex in jeder Node gespeichert, sodass man an der Liste parallel herumoperieren kann und gleichzeitig an mehreren Stellen einfügen/löschen kann.