ich habe folgendes Problem (im folgenden vereinfacht dargestellt):

set<int, less<int> > m;
m.insert(3);
m.insert(4);
m.insert(1);
for (set<int>::iterator iter = m.begin(); iter != m.end(); iter++)
    cout << *iter << endl;

Wenn ich das Progrämmchen so kompiliere und ablaufen lasse, dann bekomme ich ohne Probleme die Zahlen in aufsteigender Reihenfolge.

Wenn ich aber set wie folgt definiere:

set<int, binary_negate<less<int> > > m;

dann bekomme ich die folgende Fehlermeldung

/usr/include/c++/4.1.0/bits/stl_set.h: In constructor ‘std::set<_Key, _Compare, _Alloc>::set() [with _Key = int, _Compare = std::binary_negate<std::greater<int> >, _Alloc = std::allocator<int>]’:
../main.cpp:51: instantiated from here
/usr/include/c++/4.1.0/bits/stl_set.h:155: error: no matching function for call to ‘std::binary_negate<std::greater<int> >::binary_negate()’
/usr/include/c++/4.1.0/bits/stl_function.h:343: note: candidates are: std::binary_negate<_Predicate>::binary_negate(const _Predicate&) [with _Predicate = std::greater<int>]
/usr/include/c++/4.1.0/bits/stl_function.h:338: note: std::binary_negate<std::greater<int> >::binary_negate(const std::binary_negate<std::greater<int> >&)
make: *** [main.o] Fehler 1

Ich weiß, ich kann greater benutzen, aber ich möchte wissen, wie man das Prädikat an dieser Stelle negieren kann und WARUM meine Version nicht funzt.

Vielen Dank.

Zweitens: set<int,less<int>>::iterator und set<int,greater<int>>::iterator sind zwei völlig verschiedene Typen - und nicht ineinander umwandelbar - du mußt schon in der for()-Schleife den Iterator-Typ deiner set<> verwenden.
(im angegebenen Beispiel klappt's zufälligerweise, weil less<T> der Defaultwert für den Komparator ist).

Der Hauptgrund ist also

binary_negate erfüllt in Kombination mit less (also die Strict Weak Ordering nicht, weil z.B. reflexiv.
---
das stimmt nicht ganz-> s.nächsten Beitrag

Erstens: Die Negation von less<> ist kein legaler Vergleichsoperator für set's (>= ist keine strikte Ordnung).

Ich habe jetzt folgendes ausprobiert: ich habe den Funktor greater_equal (keine strikte Ordnung) benutzt und alles funktioniert wunderbar. Anscheinend hat das nichts damit zu tun.

LordJaxom Argument gefällt mir da schon besser: binary_negate hat keinen Default-Konstruktor und Comp() findet diesen nicht.

Ich habe jetzt folgendes ausprobiert: ich habe den Funktor greater_equal (keine strikte Ordnung) benutzt und alles funktioniert wunderbar.

Dann versuch mal ein Element wiederzufinden.

CStoll schrieb:

Erstens: Die Negation von less<> ist kein legaler Vergleichsoperator für set's (>= ist keine strikte Ordnung).

Ich habe jetzt folgendes ausprobiert: ich habe den Funktor greater_equal (keine strikte Ordnung) benutzt und alles funktioniert wunderbar. Anscheinend hat das nichts damit zu tun.

Der Compiler kann leider nicht überprüfen, ob dein Prädikat die Anforderungen erfült, eine "strict weak ordering" zu sein - der würde auch ein set<int,equal<int>> durchgehen lassen. Das Problem dabei ist, daß du mit einem ungeeigneten Vergleichskriterium nichts mehr findest (set<T,Pred> definiert "gleich" als !Pred(x,key)&&!Pred(key,x) )

gh0st124 schrieb:

Ich habe jetzt folgendes ausprobiert: ich habe den Funktor greater_equal (keine strikte Ordnung) benutzt und alles funktioniert wunderbar.

Dann versuch mal ein Element wiederzufinden.

klappt ohne Probleme:

set<int, greater_equal<int> > m;
    m.insert(3);
    m.insert(4);
    m.insert(1);
    m.insert(1);
    m.insert(5);
    set<int, greater_equal<int> >::iterator f = find(m.begin(), m.end(), 1);
    if (f != m.end())
        cout << *f << " gefunden!\n";
    for (set<int, greater_equal<int> >::iterator iter = m.begin(); iter != m.end(); iter++)
        cout << *iter << endl;

Ausgabe:

1 gefunden!
5
4
3
1
1

WARUM muss es denn unbedingt eine Strict weak ordering sein? Wann geht es denn bei greater_equal(<- Keine Strict Weak Ordering) schief?

#include <set>
#include <cmath>
#include <functional>
#include <algorithm>
#include <ctime>
#include <iostream>
using namespace std;

int main()
{
    srand( time( 0 ) );

    typedef set<int, greater_equal<int> > set_type;

    set_type s;

    for ( int i = 0; i < 5000; ++i )
        s.insert( rand() );

    int count = 0;

    for ( set_type::iterator i = s.begin(); i != s.end(); ++i )
        if ( s.count( *i ) == 1
            && s.find( *i ) == i
            && s.lower_bound( *i ) == i
            && distance( i, s.upper_bound( *i ) ) == 1 )
            ++count;

    cout << count << " von " << s.size() << " richtig gefunden\n";
}

bei mir steigt das im debug Modus mit einem assert aus, ohne dieses geht es ab in die ewigen Jagdgründe.

Bei einer strikten Ordnung R gilt für zwei beliebige Werte x und y grundsätzlich eine der Beziehungen "x R y", "y R x" oder "x =_R y", auf dieser Voraussetzung arbeitet set<>. Bei einer Halbordnung gilt das nicht mehr - was unter Umständen zu Problemen führen könnte.

camper schrieb:

gh0st124 schrieb:

Ich habe jetzt folgendes ausprobiert: ich habe den Funktor greater_equal (keine strikte Ordnung) benutzt und alles funktioniert wunderbar.

Dann versuch mal ein Element wiederzufinden.

klappt ohne Probleme:

set<int, greater_equal<int> > m;
    m.insert(3);
    m.insert(4);
    m.insert(1);
    m.insert(1);
    m.insert(5);
    set<int, greater_equal<int> >::iterator f = find(m.begin(), m.end(), 1);
    if (f != m.end())
        cout << *f << " gefunden!\n";
    for (set<int, greater_equal<int> >::iterator iter = m.begin(); iter != m.end(); iter++)
        cout << *iter << endl;

Ausgabe:

1 gefunden!
5
4
3
1
1

WARUM muss es denn unbedingt eine Strict weak ordering sein? Wann geht es denn bei greater_equal(<- Keine Strict Weak Ordering) schief?

Du siehst an der Ausgabe schon dass es nicht funktioniert. Würde es funktionieren dürfte die 1 nur 1x vorkommen - ist ja schliesslich