Pointer und Prozedur



  • Hallo, hab da mal wieder ein problem... 🙄

    ein Regal ist als matrix mit 12 Zeilen und 8 Spalten modelliert. Jedes Regalfach hat eine Beschriftung und enthält Informationen über die Zahl der gespeicherten Teile und deren Bezeichunung. Beschriftung und Bezeichunung sind dynamische Zeichenketten.

    a) Definieren Sie einen geeigeneten Datentypen "Fach"!
    [i] meine Antwort:[\i]

    struct fach{
    char *beschriftung;
    char *teile_bezeichnung;
    int teile_anzahl;
    };
    

    b) Schreiben Sie eine Prozedur "tausche", welche die Inhalte zweier Fächer vertauscht ohne die Beschriftung der Fächer zu verändern.
    Als Parameter erhält diese Prozedur das Regal und die Bezeichnung der Teile, die vertauscht werden sollen. Falls eine Teilebezeichnung nicht im Regal vorkommt, bleibt das Regal unverändert.
    [i] meine Antwort:[\i]

    #define ZEILEN 12
    #define SPALTEN 8
    #define FALSE 1 //geändert
    #define TRUE 0  //geändert
    #define boolean int
    
    void tausche(struct fach *regal[ZEILEN][SPALTEN], char *bezei_a, char *bezei_b){
    int i, j;
    char h= '', bezeichung; 
    //muss man char-variablen hier initialisieren oder nicht?!
    
    for(i=0; i<ZEILEN; i++)
        for (j=0; j<SPALTEN; j++){
    //nach bezeichnung soll gesucht werden ob vorkommen oder nicht
           if(bezeichnung = false)// vergleichen(==) oder gleichsetzen(=)?!
                 return;
           else{
                 //wann nimmt man jetzt zeiger oder adresse her?! 
                 h= *bezei_a;
                 *bezei_a = *bezei_b;
                 *bezei_b = h; 
                }
    //aber irgendwie hab ich jetzt struct noch nicht verwendet?! wie kann ich damit arbeiten?!
    }
    

    danke für eure hilfe!



  • Beschriftung und Bezeichunung sind dynamische Zeichenketten.

    Sagen wir besser: Zeiger auf Zeichenketten. 🙄

    Was ich nicht ganz verstehe:
    Wenn in einem FAch zB 3 Dinge sind (also fach.teile_anzahl gleich 3 ist), wie ist das dann mit den Bezeichnungen? Sollte da nicht fach.teile_bezeichnung ein Array mit 3 Zeigern sein?

    Sag lieber FALSE oder sowas, statt false, weil false ein C++ keyword ist. (sicher ist sicher)

    Dann wird's immer schwieriger zu durchschauen: zB ist bezeichnung als char definiert. Warum vergleichst du dann auf 0 oder 1? (Dabei nehme ich an, daß du == gemeint hast).

    Bitte klarstellen, dann kriegen wir das hin.



  • In diesen online Buch steht wie man strukturen verwendet.
    Schau einfach rein, hat mir auch frücher geholfen.

    http://www.galileocomputing.de/openbook/c_von_a_bis_z/



  • Sag lieber FALSE oder sowas, statt false, weil false ein C++ keyword ist. (sicher ist sicher)

    also des mit true und false hab ich geändert.
    und ich will deswegen damit arbeiten, weil ich ja nachschauen soll ob überhaupt die gesuchte teilebezeichnung insgesamt in dem regal vorkommt.

    Was ich nicht ganz verstehe:
    Wenn in einem FAch zB 3 Dinge sind (also fach.teile_anzahl gleich 3 ist), wie ist das dann mit den Bezeichnungen? Sollte da nicht fach.teile_bezeichnung ein Array mit 3 Zeigern sein?

    die teile bezeichnungen soll nicht getauscht werden, nur quasi der inhalt.
    oder versteh ich dich grad nicht?!



  • Ich denke, du hast mich falsch verstanden. Ich wittere da einen Denkfehler (entweder bei dir oder bei mir).

    Also: Der Inhalt des Faches wird ja nur durch die Bezeichnungen beschrieben. Warum sollte ich die dann nicht vertauschen? Sonst würden wir ja für die Dinge im Regal die Namen ändern, und das soll nicht so sein, denke ich.

    Ich schlage also, auch um Kommunkationsprobleme zu vermeiden, eine stärker objektorientiere Umstrukturierung vor:

    /* Eine Struktur für Dinge im Regal, falls man sie später genauer beschreiben will */
    typedef struct ding_im_regal {
        char *bezeichnung;
    } DING, *PT_DING;
    
    /* Eine Struktur für Fächer im Regal*/
    typedef struct fach_im_regal {
        char *beschriftung;
        /* Ein Zeiger auf Zeiger auf Dinge im Regal;
           kein Array, um uns nicht auf fixe Anzahlen beschränken zu müssen.
           Also auf Allozierungen vorbereiten. */
        PT_DING *teile_bezeichnung;
        /* Die Anzahl der Zeiger in *teile_bezeichnung */
        int teile_anzahl;
    } FACH, *PT_FACH;
    

    Dann kannst du, wenn du Teile von einem Fach ins andre räumst, einfach mit Zeigern auf DING (also PT_DING's) arbeiten, die du ganz leicht vertauchen kannst; selbst wenn ein Ding durch 17 Attribute beschrieben wird.



  • Dinge im Regal würde ich dann über ihren PT_DING identifizieren, der ist eindeutig. Die Bezeichnung ist nicht eindeutig, denn du kannst mehere Dinge mit Bezeichnung "Apfel" ins Regal räumen. Woher soll denn der Computer wissen, welches du dann mit "Apfel" meinst?

    Die Vertauschungsroutine funktioniert dann nach folgendem Schema:

    int vertauschen(PT_DING ding, PT_FACH zielfach) {
        /* zuerst das ding im regal suchen, also das Fach finden, wo es ist */
        /* dann aus diesem Fach den Zeiger auf das DIng entfernen */
        /* dann den Zeiger ins zielfach eintragen */
        /* fertig */
    }
    

    Wenn du der Routine auch noch angibst, in welchem Fach das Ding gerade ist, musst du es nicht suchen. Ist allerdings prinzipiell eine Überbestimmung.


Log in to reply