找出字符串是否以C++； 我如何知道字符串在C++中以另一个字符串结尾？

让<代码> < <代码>是一个字符串，<代码> b>代码>您所寻找的字符串。使用

a.substr

获取

a

的最后n个字符，并将它们与b进行比较（其中n是

b

的长度）

或者使用

std:：equal

（包括

）

例：

只需使用以下方法比较最后n个字符：

#包括
bool hasEnding（std:：string const&fullString，std:：string const&ending）{
if（fullString.length（）>=ending.length（））{
返回（0==fullString.compare（fullString.length（）-ending.length（），ending.length（），ending））；
}否则{
返回false；
}
}
int main（）{
std:：string test1=“binary”；
std:：string test2=“一元”；
std:：string test3=“第三方”；
std:：string test4=“ry”；
std:：string end=“nary”；
std：：cout您可以使用

基于评论的完整示例：

bool EndsWith(string &str, string& key)
{
size_t keylen = key.length();
size_t strlen = str.length();

if(keylen =< strlen)
    return string::npos != str.rfind(key,strlen - keylen, keylen);
else return false;
}

bool-EndsWith（字符串和str，字符串和键）
{
size_t keylen=key.length（）；
长度=长度（）；
if（keylen=
当使用
std:：mismatch
方法从两个字符串的末尾向后迭代时，可以达到此目的：

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() );

使用此功能：

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());
}

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

使用
boost:：algorithm:：以
结尾（参见示例）：

#包括
//使用常量字符*
断言（boost:：algorithm:：以（“mystring”、“ing”）结尾）；
//也适用于std:：string
标准：：字符串干草堆（“mystring”）；
标准：：线针（“ing”）；
断言（boost:：algorithm:：以（haystack，pine）结尾）；
标准：字符串2（“ng”）；
断言（！boost:：algorithm:：以（haystack2，pine）结束_）；
我知道这个问题是针对C++的，但是如果有人需要一个好的OL模式C函数来做这个：


/*  returns 1 iff str ends with suffix  */
int str_ends_with(const char * str, const char * suffix) {

  if( str == NULL || suffix == NULL )
    return 0;

  size_t str_len = strlen(str);
  size_t suffix_len = strlen(suffix);

  if(suffix_len > str_len)
    return 0;

  return 0 == strncmp( str + str_len - suffix_len, suffix, suffix_len );
}

我认为最简单的C++解决方案是：
bool endsWith(const string& s, const string& suffix)
{
    return s.rfind(suffix) == std::abs(s.size()-suffix.size());
}

警告：如果匹配失败，这将在放弃之前向后搜索整个字符串，因此可能会浪费大量的周期。
关于Grzegorz Bazior响应。我使用了此实现，但原始实现存在错误（如果将“.”与“.so”进行比较，则返回true）。
我建议修改功能：

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());
}

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

与上面一样，这里是我的解决方案

 template<typename TString>
  inline bool starts_with(const TString& str, const TString& start) {
    if (start.size() > str.size()) return false;
    return str.compare(0, start.size(), start) == 0;
  }
  template<typename TString>
  inline bool ends_with(const TString& str, const TString& end) {
    if (end.size() > str.size()) return false;
    return std::equal(end.rbegin(), end.rend(), str.rbegin());
  }

模板
内联布尔从（常量字符串和str，常量字符串和start）开始{
if（start.size（）>str.size（））返回false；
返回str.compare（0，start.size（），start）==0；
}
模板
内联布尔结束于（常量字符串和str，常量字符串和end）{
if（end.size（）>str.size（））返回false；
返回std:：equal（end.rbegin（），end.rend（），str.rbegin（））；
}
使用以下方法检查str是否有后缀：

/*
Check string is end with extension/suffix
*/
int strEndWith(char* str, const char* suffix)
{
  size_t strLen = strlen(str);
  size_t suffixLen = strlen(suffix);
  if (suffixLen <= strLen) {
    return strncmp(str + strLen - suffixLen, suffix, suffixLen) == 0;
  }
  return 0;
}

/*
检查字符串是否以扩展名/后缀结尾
*/
int strength（字符*str，常量字符*后缀）
{
尺寸\u t strLen=strLen（str）；
大小后缀=strlen（后缀）；
如果（subfixlen我认为发布一个不使用任何库函数的原始解决方案是有意义的

// Checks whether `str' ends with `suffix'
bool endsWith(const std::string& str, const std::string& suffix) {
    if (&suffix == &str) return true; // str and suffix are the same string
    if (suffix.length() > str.length()) return false;
    size_t delta = str.length() - suffix.length();
    for (size_t i = 0; i < suffix.length(); ++i) {
        if (suffix[i] != str[delta + i]) return false;
    }
    return true;
}

注意，从STD::String开始，C++有30个字符串可能最终成为可用的，如果你不从遥远的未来读取这个字符串，你可以使用StcsIs/EnthsC++ C++ 17：
#if __cplusplus >= 201703L // C++17 and later 
#include <string_view>

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

static bool startsWith(std::string_view str, std::string_view prefix)
{
    return str.size() >= prefix.size() && 0 == str.compare(0, prefix.size(), prefix);
}
#endif // C++17

 IMO，C++字符串显然是不正常的，并没有被用于实际的代码中。但是希望它会变得更好。
 如果你像我一样，不那么喜欢C++的纯粹性，这里有一个老的SkooPosiple。当字符串比一小部分字符多时，有一些优势，如大多数<代码> MMECMP < /C>实现尽可能比较机器字

您需要控制字符集。例如，如果此方法与utf-8或wchar类型一起使用，则会有一些缺点，因为它不支持字符映射-例如，当两个或多个字符同时使用时

让我扩展一下不区分大小写的版本（）

#包括
#包括
静态bool endswithcase不敏感（const std:：string和value，const std:：string和ending）{
if（ending.size（）>value.size（））{
返回false；
}
返回std:：equal（ending.crbegin（）、ending.crend（）、value.crbegin（），
[]（常量无符号字符a，常量无符号字符b）{
返回std:：tolower（a）==std:：tolower（b）；
}
);
}
另一个选项是使用正则表达式。以下代码使搜索对大写/小写不敏感：

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

可能效率不高，但易于实现。
使用
中的std:：equal算法进行反向迭代：

std::string LogExt = ".log";
if (std::equal(LogExt.rbegin(), LogExt.rend(), filename.rbegin())) {
   …
}

找到了类似“startWith”问题的好答案：


您可以采用只搜索字符串中最后一个位置的解决方案：

bool endsWith（常量标准：：字符串和堆栈，常量标准：：字符串和指针）{
返回stack.find（needle，stack.size（）-needle.size（））！=std:：string:：npos；
}

这种方法可以使它简短、快速，使用标准C++并使之可读。< /P> < P2 >我的两分文：
bool endsWith(std::string str, std::string suffix)
{
   return str.find(suffix, str.size() - suffix.size()) != string::npos;
}

bool-endswith（const-std:：string和str，const-std:：string和后缀）
{
字符串：：size_type totalSize=str.size（）；
字符串：：size_type后缀size=suffix.size（）；
if（总大小<后缀大小）{
返回false；
}
返回str.compare（totalSize-suffix，suffix，suffix）==0；
}

测试

#include <iostream>
int main()
{
   cout << EndsWith(u8"o!hello!1", u8"o!") << endl; 
   cout << EndsWith(u8"o!hello!", u8"o!") << endl; 
   cout << EndsWith(u8"hello!", u8"o!") << endl; 
   cout << EndsWith(u8"o!hello!o!", u8"o!") << endl; 
   return 0;
}

如果像我一样需要endsWith检查文件扩展名，可以使用
std:：filesystem
库：

std::filesystem::path("/foo/bar.txt").extension() == ".txt"

是的，这是最好的方法，毫无疑问。我总是讨厌计算子串的索引，它很容易出错。我宁愿从两个字符串的结尾向后迭代，试图找到一个不匹配的地方。“NoDORIN我不同意。这是一个不需要思考的方法。最好的方法是使用一个库。这是一个耻辱的C++标准库。有用的东西太少了。@masterxilo你建议用什么库来解决这个问题，这是怎么回事
#include <string>
#include <cctype>

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

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

std::string LogExt = ".log";
if (std::equal(LogExt.rbegin(), LogExt.rend(), filename.rbegin())) {
   …
}

bool endsWith(std::string str, std::string suffix)
{
   return str.find(suffix, str.size() - suffix.size()) != string::npos;
}

bool endswith(const std::string &str, const std::string &suffix)
{
    string::size_type totalSize = str.size();
    string::size_type suffixSize = suffix.size();

    if(totalSize < suffixSize) {
        return false;
    }

    return str.compare(totalSize - suffixSize, suffixSize, suffix) == 0;
}

bool EndsWith(const std::string& data, const std::string& suffix)
{
    return data.find(suffix, data.size() - suffix.size()) != string::npos;
}


#include <iostream>
int main()
{
   cout << EndsWith(u8"o!hello!1", u8"o!") << endl; 
   cout << EndsWith(u8"o!hello!", u8"o!") << endl; 
   cout << EndsWith(u8"hello!", u8"o!") << endl; 
   cout << EndsWith(u8"o!hello!o!", u8"o!") << endl; 
   return 0;
}

0 
1 
1 
1 

std::filesystem::path("/foo/bar.txt").extension() == ".txt"