Was ist spaghetti-code?

Mir mehr moderne Beispiel der spaghetti-code ist, wenn man 20-dlls und alle DLL-Verweise gegenseitig in die eine oder andere Weise. Ihre dependency graph sieht aus wie eine große blob, und Ihrer code-Hopfen-alle über dem Platz, ohne wirkliche Ordnung. Alles ist voneinander abhängig.

InformationsquelleAutor der Antwort Brian Genisio

Ich bin nicht ziehen diese aus meinem Kopf. Dies ist, was ich hatte, mit zu arbeiten, wenn auch vereinfacht. Sagen wir mal so, im Grunde haben Sie ein Programm, das die Bedürfnisse einer enum:

enum {
   a, b, c;
} myenum;

Sondern das, was wir haben, ist

HashTable t;
t["a"] = 0;
t["b"] = 1;
t["c"] = 2;

Aber natürlich keine Implementierung einer hash-Tabelle ist gut genug, so gibt es eine lokale Implementierung von hash-Tabellen, die enthält etwa 10 mal mehr code als eine Durchschnittliche open-source-Implementierung mit der Hälfte der features und die doppelte Anzahl an bugs. Die HashTable ist eigentlich definierten virtuellen, und es gibt eine Fabrik HashTableFactory zum erstellen von Instanzen des HashTables, aber wahr, um das Muster HashTableFactory ist auch virtuell. Um zu verhindern, dass ein infite Kaskade von virtuellen Klassen gibt es eine Funktion

HashTableFactory *makeHashTableFactor();

Damit überall, wo der code muss myenum's er trägt einen Verweis auf die Instanz der HashTable-und HashTableFactory, in Fall, dass Sie möchten, um mehr HashTable ist. Aber warten Sie, das ist noch nicht alles! Dies ist nicht, wie die hash-Tabelle wird initialisiert, aber es ist getan, indem Sie schreiben einen code, der liest XML:

<enum>
  <item name="a" value="0"/>
  <item name="b" value="1"/>
  <item name="c" value="2"/>
</enum>

und das einfügen in eine hash-Tabelle. Aber der code ist "optimiert", damit es nicht Lesen einer ascii-Datei myenum.xml, sondern es gibt eine compile-Zeit-Skript, das generiert:

const char* myenumXML = [13, 32, 53 ....];

aus myenum.xml und die hash-Tabelle initialisiert, die durch eine Funktion:

void xmlToHashTable(char *xml, HashTable *h, HashTableFactory *f);

genannt:

HashTableFactory *factory = makeHashTableFactory();
HashTable *t = facotry.make();
xmlToHashTable(myenumXML, t, f);

Ok, wir haben also eine Menge code, um eine enum-Struktur. Es ist im Grunde in einer Funktion verwendet:

void printStuff(int c) {
   switch (c) {
   case a: print("a");
   case b: print("b");
   case c: print("c");
   }
}

- und das heißt in einem Kontext, wo:

void stuff(char* str) {
   int c = charToEnum(str);
   printStuff(c);
}

Also, was wir tatsächlich haben, ist statt

void stuff(char *str) {
   printf(str);
}

haben wir manged zu erzeugen Tausende von code-Zeilen (private neue, buggy, Komplex, Implementierung von Hashtabellen, und xml-Leser und-Schreiber) an die Stelle der oben genannten 3.

InformationsquelleAutor der Antwort Joe Smith

Echte spaghetti-code wurde in COBOL und verwendet die ALTER-Anweisung.

Hier ist ein Beispielwährend eine "humor", ich habe gesehen, diese Art der Sache. Fast gefeuert, einmal für erwähnenswert, dass jedes Programm mit einer Alter-Anweisung war offensichtlich in einem Zustand der Sünde. Ich weigerte mich zu "pflegen", das Programm, es ging schneller, um es zu ersetzen, als es zu verstehen.

InformationsquelleAutor der Antwort S.Lott

Du hast danach gefragt, du wirst es bekommen:

Dies ist die Quelle eines DOS .com-Datei, spielt der Blue Danube waltz. Die ausführbare Datei ist nur 176 bytes in der Größe. Code wird wieder verwendet, da die Daten und Umgekehrt.

.286
.model tiny

g4 equ 55-48           ; removed note-decoding !
a4 equ 57-48           ; now: storing midi-notes for octaves 0..2 and convert
h4 equ 59-48           ; to 4..6 with a simple add 48.

c5 equ 60-48
d5 equ 62-48
e5 equ 64-48
g5 equ 67-48
h5 equ 71-48

c6 equ 72-48
d6 equ 74-48
e6 equ 76-48
g6 equ 79-48           ; = 00011111b

pp  equ 0              ;  c4 is not used in the walz, using it as play-pause.
EOM equ 1              ; c#4 is also available... End Of Music
                       ; warning: experts only beyond this point !

pau1 equ 00100000b     ; bitfield definitions for note-compression
pau2 equ 01000000b     ; you can or a pau to each note!
pau3 equ 01100000b

;rep1 equ 01000000b    ; rep1 is history (only used once).
;rep3 equ 11000000b    ; rep3 was never used.

rep2 equ 10000000b     ; or a rep2 to a note to play it 3 times.

drumsize equ 5

.code
org 100h

start:
                mov  ah,9
                mov  dx,offset msg
                int  21h                    ; print our headerstring

                mov  dx,0330h               ; gus midi megaem -port
                mov  si,offset music_code   ; start of music data

mainloop:

    ; get new note (melody)

                xor  bp,bp                  ; bp= repeat-counter

                lodsb                       ; get a new note
                cmp  al, EOM                ; check for end
                jne  continue
                ret

continue:
                jns  no_rep2                ; check for rep2-Bit
                inc  bp
                inc  bp                     ; "build" repeat-counter

no_rep2:
                push ax                     ; save the note for pause

    ; "convert" to midi-note

                and  al,00011111b
                jz   skip_pp                ; check pp, keep it 0
                add  al,48                  ; fix-up oktave

skip_pp:
                xchg ax,bx                  ; bl= midi-note

play_again:
                mov  cl,3
                push cx                     ; patch program (3= piano)
                push 0c8h                   ; program change, channel 9

    ; wait (cx:dx) times

                mov  ah,86h                 ; wait a little bit
                int  15h

    ; prepare drums

                dec  di                     ; get the current drum
                jns  no_drum_underflow
                mov  di,drumsize

no_drum_underflow:

    ; play drum

                push dx                     ; volume drum
                push [word ptr drumtrk+di]  ; note   drum
                mov  al,99h
                push ax                     ; play channel 10

    ; play melody

                push dx                     ; volume melody
                push bx                     ; note   melody

                dec  ax                     ; replaces dec al :)

                push ax                     ; play channel 9

    ; send data to midi-port

                mov  cl,8                   ; we have to send 8 bytes

play_loop:
                pop  ax                     ; get the midi event
                out  dx,al                  ; and send it
                loop play_loop

    ; repeat "bp" times

                dec  bp                     ; repeat the note
                jns  play_again

    ; check and "play" pause

                xor  bx,bx                  ; clear the note, so we can hear
                                            ; a pause
    ; decode pause value

                pop  ax
                test al,01100000b
                jz   mainloop               ; no pause, get next note

    ; decrement pause value and save on stack

                sub  al,20h
                push ax
                jmp  play_again             ; and play next drum

; don't change the order of the following data, it is heavily crosslinked !
music_code      db pp or rep2

                db g4 or rep2 or pau1
                db h4 or pau1, d5 or pau1, d5 or pau3
                db d6 or pau1, d6 or pau3, h5 or pau1, h5 or pau3

                db g4 or rep2 or pau1
                db h4 or pau1, d5 or pau1, d5 or pau3
                db d6 or pau1, d6 or pau3, c6 or pau1, c6 or pau3

                db a4 or rep2 or pau1
                db c5 or pau1, e5 or pau1, e5 or pau3
                db e6 or pau1, e6 or pau3, c6 or pau1, c6 or pau3

                db a4 or rep2 or pau1
                db c5 or pau1, e5 or pau1, e5 or pau3
                db e6 or pau1, e6 or pau3, h5 or pau1, h5 or pau3

                db g4 or rep2 or pau1
                db h4 or pau1, g5 or pau1, g5 or pau3
                db g6 or pau1, g6 or pau3, d6 or pau1, d6 or pau3

                db g4 or rep2 or pau1
                db h4 or pau1, g5 or pau1, g5 or pau3
                db g6 or pau1, g6 or pau3, e6 or pau1, e6 or pau3

                db a4 or rep2 or pau1
                db c5 or pau1, e5 or pau1, e5 or pau3, pp or pau3
                db c5 or pau1, e5 or pau1, h5 or pau3, pp or pau3, d5 or pau1

                db h4 or pau1, h4 or pau3
                db a4 or pau1, e5 or pau3
                db d5 or pau1, g4 or pau2

;                db g4 or rep1 or pau1
; replace this last "rep1"-note with two (equal-sounding) notes
                db g4
                db g4 or pau1

msg             db EOM, 'Docking Station',10,'doj&sub'
drumtrk         db 36, 42, 38, 42, 38, 59  ; reversed order to save some bytes !

end start

InformationsquelleAutor der Antwort Nils Pipenbrinck

In einfachen Worten spaghetti-code ist jeder code in einer beliebigen Programmiersprache, in der es nicht möglich ist, auf die Spur, die nächste post von der Ausführung, oder zumindest schwierig zu bestimmen, wo der nächste Punkt geht in der Antwort eine Aktion.

InformationsquelleAutor der Antwort Ziaullah

Hier ist die Duff ' s Devicevon Matt ' s Antwort auf diese Frage:

int n = (count + 7) /8;
switch (count % 8) {
case 0: do { *to = *from++;
case 7:      *to = *from++;
case 6:      *to = *from++;
case 5:      *to = *from++;
case 4:      *to = *from++;
case 3:      *to = *from++;
case 2:      *to = *from++;
case 1:      *to = *from++;
           } while (--n > 0);
}

InformationsquelleAutor der Antwort Federico A. Ramponi

Haben Sie jemals sah generierten code von Flex/Bison-scanner und-generator? Eine Vielzahl von labels und Präprozessor-Direktiven.

Ist es absolut unmöglich zu verstehen, was drin ist.. und absolut unmöglich, zu Folgen Strömung des Programms.

Das ist definitiv spaghetti-code.

InformationsquelleAutor der Antwort Jack