MG Mud User | 88f1247 | 2016-06-24 23:31:02 +0200 | [diff] [blame^] | 1 | sort_array(E) |
| 2 | |
| 3 | FUNKTION: |
| 4 | mixed *sort_array(mixed *arr, mixed func [, mixed ob]) |
| 5 | |
| 6 | PARAMETER: |
| 7 | arr - zu sortierendes Array |
| 8 | func - zu rufende Methode; kann als String (Funktionsname) oder |
| 9 | Closure uebergeben werden |
| 10 | ob - Objekt, an dem Methode gerufen werden soll; kann als String |
| 11 | (Filename) oder Objektpointer uebergeben werden |
| 12 | |
| 13 | BESCHREIBUNG |
| 14 | Erzeugt eine (flache) Kopie des Arrays 'arr' und sortiert diese mit der |
| 15 | Sortierfunktion 'func'. Die sortierte Kopie wird dann zurueckgegeben. |
| 16 | |
| 17 | Die Elemente des zu sortierenden Arrays werden paarweise an die |
| 18 | Sortierfunktion als Argumente uebergeben. |
| 19 | Die Sortierfunktion sollte eine Zahl |
| 20 | - >0 zurueckgeben, wenn die Elemente in der falschen |
| 21 | Reihenfolge sind |
| 22 | - <=0 zurueckgeben, wenn die Elemente in der richtigen |
| 23 | Reihenfolge sind. |
| 24 | |
| 25 | Verwendung von Methoden: |
| 26 | Wenn bei der Angabe von 'func' kein Objekt 'ob' in Form eines Strings |
| 27 | oder Objekts angegeben wird, wird this_object() angenommen. |
| 28 | |
| 29 | Verwendung von Closures: |
| 30 | Es koennen Lfun-, Lambda- und Inline-Closures verwendet werden. |
| 31 | Lfun-Closures koennen, wenn im selben Objekt vorhanden, auch |
| 32 | 'private' oder/und 'static' deklariert sein, muessen aber zu dem |
| 33 | Zeitpunkt der Verwendung bekannt sein (Funktionsprototypen benutzen). |
| 34 | Von der Verwendung von Lambda-Closures wird ausdruecklich abgeraten. |
| 35 | |
| 36 | BEMERKUNGEN: |
| 37 | (1) sort_array() unterstuetzt keinen extra-Parameter |
| 38 | |
| 39 | (2) Achtung, die Elemente in 'arr' werden nicht tief kopiert, sind sie |
| 40 | also selbst Arrays oder Mappings, so fuehrt eine Aenderung im Rueckgabe- |
| 41 | Array zur Aenderung im Ursprungsarray: |
| 42 | |
| 43 | int *i, *j; |
| 44 | i=({({1}),({2,3}),({4,5,6})}); |
| 45 | j=sort_array(i, // sortiert der Groesse nach absteigend |
| 46 | function int ( mixed x, mixed y ) { |
| 47 | return sizeof(x) < sizeof(y); } |
| 48 | ); |
| 49 | |
| 50 | Zu diesem Zeitpunkt ist i == ({ ({1}),({2,3}),({4,5,6}) }) |
| 51 | j == ({ ({4,5,6}),({2,3}),({1}) }) |
| 52 | |
| 53 | Fuehrt man jetzt die Zuweisung j[0][0]=8; aus |
| 54 | |
| 55 | resultieren folgende Arrays: i == ({ ({1}),({2,3}),({8,5,6}) }) |
| 56 | j == ({ ({8,5,6}),({2,3}),({1}) }) |
| 57 | |
| 58 | BEISPIELE: |
| 59 | ### Sortieren von Zahlen in aufsteigender Reihenfolge ### |
| 60 | |
| 61 | int *arr = ({ 3, 8, 1, 3 }) |
| 62 | |
| 63 | // Folgend identische Resultate, aber andere Ansaetze: |
| 64 | |
| 65 | #1: nutzt die 'Efun' > als Lfun-Closure (ideal hier): |
| 66 | sort_array(arr, #'>); |
| 67 | |
| 68 | #2: mit Sortierfunktion im selben Objekt: |
| 69 | int is_greater (int a, int b) { |
| 70 | return a > b; |
| 71 | } |
| 72 | |
| 73 | #2a: sortiert mittels der Lfun im selben Objekt die Elemente in das |
| 74 | Rueckgabearray |
| 75 | sort_array(arr, "is_greater", this_object()) |
| 76 | sort_array(arr, "is_greater") |
| 77 | |
| 78 | #2b: nutzt die Lfun is_greater() als Lfun-Closure (Funktionspointer) |
| 79 | sort_array(arr, #'is_greater) |
| 80 | |
| 81 | #3: nutzt eine Lambda-Closure (langsamer, nicht fuer alle leserlich) |
| 82 | sort_array(arr, lambda(({'a, 'b}), ({#'>, 'a, 'b}))) |
| 83 | |
| 84 | #4: analog zu 3, mit Inline-Closure |
| 85 | sort_array(arr, function int (int a, int b) { |
| 86 | return a > b; } ); |
| 87 | |
| 88 | Resultat in allen Faellen: ({1,3,3,8}) |
| 89 | |
| 90 | ### Sortieren von geschachtelten Arrays ### |
| 91 | |
| 92 | arr = ({ ({ "foo", 3 }), ({ "quux", 1 }), ... }) |
| 93 | |
| 94 | // Vorgehen identisch, allerdings muss die Sortierfunktion |
| 95 | // angepasst werden (siehe auch das Beispiel unter Verwendung von |
| 96 | // Inline-Closures oben unter "Bemerkungen"): |
| 97 | |
| 98 | int is_greater (mixed *a, mixed *b) { |
| 99 | return a[1] > b[1]; |
| 100 | } |
| 101 | |
| 102 | SIEHE AUCH: |
| 103 | Arrays: filter(E), map(E) |
| 104 | Objektarrays: filter_objects(E), map_objects(E) |
| 105 | Mappings: filter_indices(E), map_indices(E) |
| 106 | |
| 107 | Sonstiges: unique_array() |
| 108 | alist, transpose_array(E) |
| 109 | |
| 110 | ---------------------------------------------------------------------------- |
| 111 | Last modified: Mon Feb 18 23:09 2008 by Arathorn |