Finden Sie heraus, wenn die Zeichenfolge endet mit einem weiteren string in C++

Verwenden Sie diese Funktion:

inline bool ends_with(std::string const & value, std::string const & ending)
{
    if (ending.size() > value.size()) return false;
    return std::equal(ending.rbegin(), ending.rend(), value.rbegin());
}

Beachten Sie, dass ab c++20 std::string wird endlich starts_with und ends_with. Scheint, wie es gibt eine chance, dass die von c++, 30 Saiten in c++ vielleicht endlich nutzbar werden, wenn Sie nicht Lesen diese aus weit entfernten Zukunft, können Sie diese startsWith/endsWith:

#include <string>

static bool endsWith(const std::string& str, const std::string& suffix)
{
    return str.size() >= suffix.size() && 0 == str.compare(str.size()-suffix.size(), suffix.size(), suffix);
}

static bool startsWith(const std::string& str, const std::string& prefix)
{
    return str.size() >= prefix.size() && 0 == str.compare(0, prefix.size(), prefix);
}

sowie einige zusätzliche Helfer überlastungen:

static bool endsWith(const std::string& str, const char* suffix, unsigned suffixLen)
{
    return str.size() >= suffixLen && 0 == str.compare(str.size()-suffixLen, suffixLen, suffix, suffixLen);
}

static bool endsWith(const std::string& str, const char* suffix)
{
    return endsWith(str, suffix, std::string::traits_type::length(suffix));
}

static bool startsWith(const std::string& str, const char* prefix, unsigned prefixLen)
{
    return str.size() >= prefixLen && 0 == str.compare(0, prefixLen, prefix, prefixLen);
}

static bool startsWith(const std::string& str, const char* prefix)
{
    return startsWith(str, prefix, std::string::traits_type::length(prefix));
}

IMO, c++ - strings sind eindeutig dysfunktional, und nicht gemacht zu werden, verwendet in der realen Welt code. Aber es gibt eine Hoffnung, dass dies besser wird mindestens.

Den std::mismatch Methode kann diesem Zweck dienen, wenn verwendet, um rückwärts Durchlaufen vom Ende der beiden strings:

const string sNoFruit = "ThisOneEndsOnNothingMuchFruitLike";
const string sOrange = "ThisOneEndsOnOrange";

const string sPattern = "Orange";

assert( mismatch( sPattern.rbegin(), sPattern.rend(), sNoFruit.rbegin() )
          .first != sPattern.rend() );

assert( mismatch( sPattern.rbegin(), sPattern.rend(), sOrange.rbegin() )
          .first == sPattern.rend() );

Lassen a ein string sein und b die Zeichenfolge, die Sie suchen. Verwenden a.substr um die letzten n Zeichen von a und vergleichen Sie b (wobei n die Länge der b)

Oder verwenden Sie std::equal (gehören <algorithm>)

Ex:

bool EndsWith(const string& a, const string& b) {
    if (b.size() > a.size()) return false;
    return std::equal(a.begin() + a.size() - b.size(), a.end(), b.begin());
}

Lassen Sie mich erweitern Joseph ' s Lösung mit der groß-und Kleinschreibung version (online-demo)

static bool EndsWithCaseInsensitive(const std::string& value, const std::string& ending) {
    if (ending.size() > value.size()) {
        return false;
    }
    return std::equal(ending.rbegin(), ending.rend(), value.rbegin(),
        [](const char a, const char b) {
            return tolower(a) == tolower(b);
        }
    );
}

Bezüglich Grzegorz Bazior Antwort. Ich habe diese Umsetzung, aber original hat bug (gibt true zurück, wenn ich Vergleiche ".." mit ".so").
Ich schlage vor, die modifizierte Funktion:

bool endsWith(const string& s, const string& suffix)
{
    return s.size() >= suffix.size() && s.rfind(suffix) == (s.size()-suffix.size());
}

andere option ist die Verwendung von regex. Der folgende code macht die Suche unempfindlich gegenüber groß - /Kleinschreibung:

bool endsWithIgnoreCase(const std::string& str, const std::string& suffix) {
  return std::regex_search(str,
     std::regex(std::string(suffix) + "$", std::regex_constants::icase));
}

wahrscheinlich nicht so effizient, aber einfach zu implementieren.

Wenn Sie wie ich sind und nicht so in C++ Purismus, hier ist ein altes skool-hybrid. Es gibt einige Vorteile, wenn die Saiten mehr als eine Handvoll Charaktere, wie die meisten memcmp Implementierungen vergleichen Maschine Worten, wenn möglich.

Müssen Sie die Kontrolle über den Zeichensatz. Zum Beispiel, wenn dieser Ansatz verwendet wird, mit utf-8-Typ oder wchar-Typ, es gibt einige Nachteile, da es keine Unterstützung für Zeichen-mapping - z.B., wenn zwei oder mehr Zeichen werden logisch identisch.

bool starts_with(std::string const & value, std::string const & prefix)
{
    size_t valueSize = value.size();
    size_t prefixSize = prefix.size();

    if (prefixSize > valueSize)
    {
        return false;
    }

    return memcmp(value.data(), prefix.data(), prefixSize) == 0;
}


bool ends_with(std::string const & value, std::string const & suffix)
{
    size_t valueSize = value.size();
    size_t suffixSize = suffix.size();

    if (suffixSize > valueSize)
    {
        return false;
    }

    const char * valuePtr = value.data() + valueSize - suffixSize;

    return memcmp(valuePtr, suffix.data(), suffixSize) == 0;
}