C++ std::map<std::string, int> bekommen Sie Werte, deren Schlüssel beginnt mit einer bestimmten Zeichenfolge

Bin ich mit std::map in einer solchen Art und Weise:

#include <map>
#include <string>
#include <iostream>

using namespace std;

int main(int argc, char* argv[])
{
    map<string, int> my_map;

    my_map.insert(pair<string, int>("Ab", 1));
    my_map.insert(pair<string, int>("Abb", 2));
    my_map.insert(pair<string, int>("Abc", 3));
    my_map.insert(pair<string, int>("Abd", 4));
    my_map.insert(pair<string, int>("Ac", 5));
    my_map.insert(pair<string, int>("Ad", 5));

    cout<<my_map.lower_bound("Ab")->second<<endl;
    cout<<my_map.upper_bound("Ab")->second<<endl;
    return 0;
}

http://ideone.com/5YPQmj

Ich würde gerne alle Werte, deren Schlüssel beginnt mit einer bestimmten Zeichenfolge (z.B. "Ab"). Ich kann leicht die beginnen iterator map::lower_bound. Aber wie bekomme ich eine Obere Schranke? Muss ich zum Durchlaufen der ganzen Reihe, beginnend an der unteren Grenze und prüfen Sie jede Taste, wenn er startet zwar mit "Ab"?

  • In diesem speziellen Fall my_map.lower_bound("Ac") scheint das zu tun
  • Warum holt man nicht die Grenze für "Ac"? kein Buchstabe zwischen b und c.
  • Ich brauche mehr Allgemeinen Ansatz. Beispiel war einfach das problem zu beschreiben. Ich kann jede Art von string, und anzeigen enthalten kann jede Art von string.
  • Solange wie das, was Sie brauchen, ist "beginnt mit" .. " ich denke, das wird gut funktionieren.
  • Ok, Wenn ich auf der Suche für jede Taste, die beginnt mit "Az"? Untere Schranke offensichtlich "Az" und der oberen Grenze?
  • Die meisten hier angebracht, denke ich, ist das definieren einer Funktion, so dass, sobald Sie das Letzte Zeichen in Ihrer möglichen chars, Sie 'll haben, erhöht sich der bisherige Charakter-so, dass die "Az" geworden ist, "Ba", oder so ähnlich.

InformationsquelleAutor Dejwi | 2013-04-28
  1. 1

    Fand ich eine ähnliche Antwort überprüfen Sie heraus diese Seite: (Karte komplexe Suche-Funktion)

    Code Ausüben:

    template<typename Map> typename Map::const_iterator
find_prefix(Map const& map, typename Map::key_type const& key)
{
    typename Map::const_iterator it = map.upper_bound(key);
    while (it != map.begin())
    {
        --it;
        if(key.substr(0, it->first.size()) == it->first)
            return it;
    }

    return map.end(); //map contains no prefix
}

    Sieht es aus, als wenn in diesem Beispiel die Iteration von der upper_bound nach hinten bis zum Anfang der Suche nach dem bestimmten substring

    Dieses Beispiel ist etwas anders, aber sollte der server als ein guter Baustein

    • Man muss vielleicht erwähnen, dass dies ist ein sehr nicht-optimale Lösung und ein weiteres datastructure ist in Ordnung.
    InformationsquelleAutor Matt Stokes
  2. 1
    class BeginWithKey
{
public:
    BeginWithKey(const string key);
    bool operator()(const string& s,const int x);
private:
    const string& key_;
};

BeginWithKey::BeginWithKey(const string key):key_(key)
{
}

bool BeginWithKey::operator()(const string& s, const int& rh)
{
    bool begin = true;

    for(int i = 0; i < key_.size() && begin; ++i)
        begin = (s[i] == key_[i]);
    return !begin;
}

int main()
{
    //your code

    //copying the map object
    map<string, int> copy = my_map;

    //removing the strings not beginning with abc
    BeginWithKey func("abc");
    remove_if(copy.begin(), copy.end(), func);

    return 0;
}

    Funktioniert der code mit jedem string-Taste.

    InformationsquelleAutor lucas92
  3. 1

    können Sie Boost-filter iterator, die Ihnen eine "begin" und "end" - iterator von der normalen Iteratoren, wenn Sie ein Prädikat (eine bool-Funktion, die sagt, welche Werte gehören)

    Beispiel:

    template <class Predicate>
boost::filter_iterator<Predicate, map<string,int>::const_iterator> begin(Predicate predicate) const
{
    return boost::make_filter_iterator(predicate, my_map.begin(), my_map.end());
}
template <class Predicate>
boost::filter_iterator<Predicate, map<string,int>::const_iterator> end(Predicate predicate) const
{
    return boost::make_filter_iterator(predicate, my_map.end(), my_map.end());
}

struct isMatch
{
    isMatch(const std::string prefix) {m_prefix = prefix;};
    bool operator()(std::string value)
    {
        return value.find_first_of(m_prefix) == 0;
    };
    std::string m_prefix;
};

//using:
isMatch startWithAb("Ab");
auto myBegin = boost::filter_iterator<startWithAb> begin();
auto myEnd = boost::filter_iterator<startWithAb> end();
    InformationsquelleAutor Roee Gavirel
Schreibe einen Kommentar