Mein Problem ist folgendes:
Ich verwende die Funktion std::search aus dem Header <algorithm>, um in einem String einen Teilstring zu suchen (wahlweise case-(in)sensetive). Dazu übergebe ich eine entsprechende Vergleichsmethode, die natürlich statisch ist. (Die Funktion std::search wird innerhalb einer Methode (nicht statisch) meiner Klasse aufgerufen.) Nun kann man aber festlegen, dass in der Suchmaske auch Wildcards enthalten sein dürfen (z.B. '?' für einzelne Zeichen). Die dahinter steckende Suchlogik ist ja nicht schwer, aber das Problem ist, dass ich der Vergleichsfunktion, die std::search erwartet, nicht noch weitere Parameter übergeben kann und die Vergleichsmethode ja selbst statisch ist (muss sie ja) und ich so auch keinen Zugriff auf den this-Zeiger habe.

Hat jemand eine Idee, wie ich das Problem lösen kann?

viele Grüße und danke schonmal,
Tommy.

Ich kannte Funktoren bisher nicht und habe mich mal schlau gemacht (-> http://www.cpp-tutor.de/cpp/le18/le18_03.htm)... .
Also wenn ich das richtig verstanden habe, bringen die mich aber nicht weiter.

Hier mal ein (Pseudo-)Code, der mein Problem verdeutlicht:

class A
{
    std::string str;
    bool casesense;

    static bool compare1(char s1, char s2)
    { return (s1 == s2); }
    bool compare2(char s1, char s2) const
    {
         if(this->casesense) // Problem, da this ja nur ohne static geht, std::search aber ne Funktion erwartet.
            return (toupper(s1) == toupper(s2));
         else
            return (s1 == s2);
    }

    public:
      int suche(const std::string& what) const
      {
         std::string::const_iterator i = std::search(str.begin(), str.end(), what.begin(), what.end(), compare1);
         if(i == str.end())
            return -1;
         else
            return i - str.begin();
      }
}

Wenn ich im obrigen Code nun compare2 an std::search statt compare1 übergebe, gibts Compilier-Fehler. Wie kann ich nun meine compare2-Methode (anstatt der (statischen) compare1-Funktion) übergeben, sodass ich innerhalb der Vergleichsfunktion, die ja von std::search aufgerufen wird, auf den this-Zeiger zugreifen kann?

Ich habe auch schon Interessantes aus dem Header <functional> wie z.B. mem_fun_ref gefunden, aber irgenwie löst das mein Problem nicht, auch wenn vllt. die Richtung stimmt .

Auf jeden Fall danke für Deine/eure Bemühungen!

PS: Beim Vertauschen der Iteratoren bei std::search gibts ne Assertion mit "invalid iterator range...". Das habe ich schon ausprobiert.

Du kannst ja rbegin und rend brauchen, um von hinten nach vorne zu arbeiten.

Wie würdest Du denn eine solche Funktion deklarieren?

thx!

Jetzt mal rein allgemein gesehen. Ich würde das ganze Design wahrscheinlich anders machen. Kommt halt auf die Anforderungen an.

Dann hab ich damit noch ein Problemchen:

Du kannst ja rbegin und rend brauchen, um von hinten nach vorne zu arbeiten.

Die Methoden geben alle einen 'reverse_iterator' zurück. Die Funktion std::search erwartet aber einen Forward-Iterator und anscheinend sind die auch nicht kompatibel (Compiler beschwert sich^^).

Nochmal danke, hast mir echt weitergeholfen!

class A
{    
    std::string str;
    bool casesense;

public:
    int suche(const std::string& what) const
    {
        return str.find (what.c_str());
    }
};

Der Rückgabewert für nicht gefunden ist jetzt einfach std::string::npos

Schau sonst mal hier rein:
http://www.cplusplus.com/reference/string/string/find.html

Da findest du bestimmt das,wonach du suchst. Und wenn nicht, dann schau nochmal hier nach:
http://www.cplusplus.com/reference/algorithm/

Und wenn du dann immernoch nicht das passende gefunden hast, schreibst du was eigenes. Und wenn du das dann nicht hinkriegst mit deiner genauen Vorstellung nochmal posten.

Ich persönlich tippe einfach mal ins Blaue, dass du std::string::find_first_of() suchst. Jetzt musst du diese Funktion nur noch einsetzen (was nicht allzu schwer ist).

Ich will das, was std::string::rfind macht, effizient nachprogrammieren bzw. suche dafür eine Funktion alá std::search (was ja äquivalent zu std::string::find ist). Der einfach Grund für das Vorhaben ist (u.a.), dass rfind bzw. find keine Wildcards unterstützen .

int suche(const std::string& what) const
    {
        std::string::const_reverse_iterator i = std::search(str.rbegin(), str.rend(), what.begin(), what.end(), compare (casesense) );
        return str.rend() - i - 1;
    }

oder man geht zum jeweiligen Element gehörigen normalen Iterator zurück.

int suche(const std::string& what) const
    {
        std::string::const_iterator i = std::search(str.rbegin(), str.rend(), what.begin(), what.end(), compare (casesense) ).base();
        return i - str.begin() - 1;
    }

Für Faule gibt es natürlich auch noch string::find&co

Für Faule gibt es natürlich auch noch string::find&co

Was hast das mit faul zu tun, wenn man die Algorithmen nimmt, die auf das Problem passen? (Auch wenn das hier jetzt nicht der Fall ist)

Ich schreibe ja auch nicht jedesmal, wenn ich etwas sortieren will den Algorithmus neu..

Aber bzgl.:

camper schrieb:

Für Faule gibt es natürlich auch noch string::find&co

...haste Dir mal meinen vorletzten Post durchgelesen? Anscheinend *nicht*...

Auch nochmal @drakon danke!