[erledigt] Frage bzgl. Funktion (Rückgabewert negieren)

[Elle4u]

Hallo,

ich habe für die Sortierung immer zwei Funktionen.

z.B.

Code: Alles auswählen

bool CompareDate( tItem *pData1, tItem *pData2 )
{
  return( FileDB [pData1->FileDBIndex].Date < FileDB [pData2->FileDBIndex].Date );
}


bool CompareDateReverse( tItem *pData1, tItem *pData2 )
{
  return( FileDB [pData2->FileDBIndex].Date < FileDB [pData1->FileDBIndex].Date );
}

oder

Code: Alles auswählen

bool CompareDuration( tItem *pData1, tItem *pData2 )
{
  return( FileDB [pData2->FileDBIndex].Duration > FileDB [pData1->FileDBIndex].Duration );
}


bool CompareDurationReverse( tItem *pData1, tItem *pData2 )
{
  return( FileDB [pData1->FileDBIndex].Duration > FileDB [pData2->FileDBIndex].Duration );
}

Jetzt finde ich es eigentlich Quatsch das selbe 2x zu schreiben (ein Sortierung kann ja auch mal etwas komplexer werden) und dachte mir, dass ich ja einfach einen bool mit übergeben kann ob Reverse oder nicht.

Code: Alles auswählen

bool CompareDuration( tItem *pData1, tItem *pData2, bool Reverse )

Jetzt muss ich ja nur den Rückgabewert genau negieren, wenn Reverse = TRUE.


Frage nun:
Geht das irgendwie einfacher, als es in eine if zu packen? Weil so kann ich es ja direkt 2x schreiben...

Code: Alles auswählen

  if (!Reverse) return( FileDB [pData1->FileDBIndex].Duration > FileDB [pData2->FileDBIndex].Duration );
  else          return( FileDB [pData2->FileDBIndex].Duration > FileDB [pData1->FileDBIndex].Duration );

oder

Code: Alles auswählen

  ret = ( FileDB [pData1->FileDBIndex].Duration > FileDB [pData2->FileDBIndex].Duration );

  if (!Reverse) return( ret );
  else          return( !ret );

Also evtl. durch &&-Verknüpfung?

[Elle4u]

[quote=""Elle4u""]Also evtl. durch &&-Verknüpfung?[/quote]

Keiner eine bessere Idee?

Dann werde ich es nämlich wie in meinem letzten Beispiel machen...

[astrogator]

sorry, falscher Hinweis

Gruß
Ralf

[asrael]

[quote=""Elle4u""]
Jetzt muss ich ja nur den Rückgabewert genau negieren, wenn Reverse = TRUE.
[/quote]

Achtung, das stimmt nicht ganz. Dein Code verhält sich jetzt anders im Falle der Gleichheit der beiden Daten (das Gegenteil von < ist eben >= und nicht >). Du musst prüfen, ob das einen Unterschied für Deine Algorithmen macht.

Ohne IF:

Code: Alles auswählen

  ret = ( FileDB [pData1->FileDBIndex].Duration > FileDB [pData2->FileDBIndex].Duration );
 
  return !Reverse && ret || Reverse && !ret;

Mit freundlichen Grüßen

asrael

[Homer]

[quote=""asrael""]

Code: Alles auswählen

  return !Reverse && ret || Reverse && !ret;

[/quote]
Das sollte mit XOR auch einfacher gehen:

Code: Alles auswählen

  return Reverse ^ ret;

Viele Grüße
Homer

[asrael]

[quote=""Homer""]Das sollte mit XOR auch einfacher gehen:

Code: Alles auswählen

  return Reverse ^ ret;

Viele Grüße
Homer[/quote]

Stimmt, wir sind ja in C.

Dann braucht man noch nicht einmal den Zwischenwert ret, sondern kann da direkt den Ausdruck (geklammert!) hinsetzen. Kurz genug, Elle?

Mit freundlichen Grüßen

asrael

[Elle4u]

[quote=""asrael""]Kurz genug, Elle? [/quote]

Danke, das müsste es wirklich sein

Ich hatte mir zwar extra noch die verschiedenen Bool-Operationen angeschaut, aber es irgendwie übersehen :

Code: Alles auswählen

XOR (Exclusive Or)
This operation is performed between two bits (a and b).
The result is 1 if either one of the two bits is 1, but not in the case that both are.
There for, if neither or both of them are equal to 1 the result is 0.

XOR (^)
a	b	a^b
0	0	0
0	1	1
1	0	1
1	1	0

[Elle4u]

[quote=""Elle4u""]Danke, das müsste es wirklich sein [/quote]

Klasse

Jetzt habe ich alle Funktionen geändert, aber dann funktioniert das Compilieren nicht mehr.
Andere Routinen (z.B. QuickSort) arbeiten mit einem Verweis:

Code: Alles auswählen

compareFnc              *pCompare;

Und das ist definiert mit

Code: Alles auswählen

typedef bool (compareFnc) (tItem *, tItem *);

Leider fehlt mir dort der weitere Durchblick, um das zu beheben...

[FireBird]

Wenn Du bei allen Vergleichsfunktionen einen 3. Parameter definiert hast, musst Du den hier auch angeben.

Code: Alles auswählen

typedef bool (compareFnc) (tItem *, tItem *, bool);

[asrael]

[quote=""Elle4u""]Andere Routinen (z.B. QuickSort) arbeiten mit einem Verweis:
[/quote]

Die eigentliche Frage hat ja schon FireBird beantwortet, aber ...

Arbeitest Du jetzt doch mit QuickSort?

Mit freundlichen Grüßen

asrael

[Elle4u]

[quote=""FireBird""]Wenn Du bei allen Vergleichsfunktionen einen 3. Parameter definiert hast, musst Du den hier auch angeben.

Code: Alles auswählen

typedef bool (compareFnc) (tItem *, tItem *, bool);

[/quote]
Leider verwende ich unterschiedliche.
Ich könnte natürlich einfach alle Funktionen mit dem bool ergänzen, auch wenn dies gar nicht genutzt wird.

[quote=""asrael""]Die eigentliche Frage hat ja schon FireBird beantwortet, aber ...

Arbeitest Du jetzt doch mit QuickSort?[/quote]

Ähhh. Öhhhh. Die Funktion heißt zumindest mal so ops: (siehe Quellcode).
Keine Ahnung, wer mir das mal eingebaut hat...

[FireBird]

[quote=""Elle4u""]Leider verwende ich unterschiedliche.
Ich könnte natürlich einfach alle Funktionen mit dem bool ergänzen, auch wenn dies gar nicht genutzt wird.[/quote]
Richtig, Du musst sie nicht unbedingt verwenden, aber die Parameter aller Funktionen müssen auf jeden Fall gleich sein.

[Erdnussnase]

Es wäre auch anders gegangen, indem Du Deine eigentlich Suchfunktion anders benennst:

z.B.

Code: Alles auswählen

bool CompareDateForBoth( tItem *pData1, tItem *pData2 )
{
  return( FileDB [pData1->FileDBIndex].Date < FileDB [pData2->FileDBIndex].Date );
}

und die Alten Namen in einem Header mit

Code: Alles auswählen

#define  CompareDate(a,b)   CompareDateForBoth(a,b)
#define  CompareDateReverse(a,b)  CompareDateForBoth(b,a)

auf die Neue umlenkst.

Das erspart Dir den dritten Parameter und bringt ganz, ganz, ganz.... leichte Laufzeitvorteile. Nur mögen einige Programmierer diesen Stil nicht.

P.S.
Statt der Defines kann man auch in den alten Funktionen auf die Neuen umlenken und dabei für Reverse die Parameter tauschen.

Code: Alles auswählen

bool CompareDateForBoth( tItem *pData1, tItem *pData2 )
{
  return( FileDB [pData1->FileDBIndex].Date < FileDB [pData2->FileDBIndex].Date );
}

bool CompareDate( tItem *pData1, tItem *pData2 ) { return CompareDateForBoth( pata1, pData2 ); }

bool CompareDateReverse( tItem *pData1, tItem *pData2 ) { return CompareDateForBoth( pata2, pData1 ); }

[Elle4u]

Ich möchte mich hiermit noch einmal bei allen bedanken, welche mir hier so tolle Antworten geliefert haben.

Ich werde mal schauen, was ich davon am einfachsten in den Sourcen umsetzten kann.

Danke!

[ibbi]

Eigentlich wollte ich mich hier nicht einmischen, aber wenn man auf Performance aus ist, kippt man die Reverse-Geschichte ganz, sortiert nur nur auf eine Art und gibt die andere einfach über eine rückläufige Schleife aus.

[Elle4u]

[quote=""ibbi""]Eigentlich wollte ich mich hier nicht einmischen, aber wenn man auf Performance aus ist, kippt man die Reverse-Geschichte ganz, sortiert nur nur auf eine Art und gibt die andere einfach über eine rückläufige Schleife aus.[/quote]

Also Performance war mir dabei eigentlich egal. :

Das mit Deinem Vorschlag geht leider nicht, da innerhalb der Liste mehrere Sortierungen vorliegen. Verzeichnisse und Dateien. Und die Verzeichnisse können dann sogar noch oben oder unten in der Liste stehen

Aber trotzdem danke für den Vorschlag.