blocks|key|5265609|text|只需使用std::string::compare比较最后n个字符|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5265610|#include+<iostream>

bool+hasEnding+(std::string+const+&fullString,+std::string+const+&ending)+{
++++if+(fullString.length()+>=+ending.length())+{
++++++++return+(0+==+fullString.compare+(fullString.length()+-+ending.length(),+ending.length(),+ending));
++++}+else+{
++++++++return+false;
++++}
}

int+main+()+{
++++std::string+test1+=+"binary";
++++std::string+test2+=+"unary";
++++std::string+test3+=+"tertiary";
++++std::string+test4+=+"ry";
++++std::string+ending+=+"nary";

++++std::cout+<<+hasEnding+(test1,+ending)+<<+std::endl;
++++std::cout+<<+hasEnding+(test2,+ending)+<<+std::endl;
++++std::cout+<<+hasEnding+(test3,+ending)+<<+std::endl;
++++std::cout+<<+hasEnding+(test4,+ending)+<<+std::endl;

++++return+0;
}|code-block|syntax|javascript|5265611|entityMap|0|LINK|mutability|MUTABLE|url|http://en.cppreference.com/w/cpp/string/basic_string/compare^0|4|K|4|K|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

Simply compare the last n characters using <a href="http://en.cppreference.com/w/cpp/string/basic_string/compare" rel="noreferrer"><code>std::string::compare</code></a>:

<pre><code>#include &lt;iostream&gt;

bool hasEnding (std::string const &amp;fullString, std::string const &amp;ending) {
 if (fullString.length() &gt;= ending.length()) {
 return (0 == fullString.compare (fullString.length() - ending.length(), ending.length(), ending));
 } else {
 return false;
 }
}

int main () {
 std::string test1 = "binary";
 std::string test2 = "unary";
 std::string test3 = "tertiary";
 std::string test4 = "ry";
 std::string ending = "nary";

 std::cout &lt;&lt; hasEnding (test1, ending) &lt;&lt; std::endl;
 std::cout &lt;&lt; hasEnding (test2, ending) &lt;&lt; std::endl;
 std::cout &lt;&lt; hasEnding (test3, ending) &lt;&lt; std::endl;
 std::cout &lt;&lt; hasEnding (test4, ending) &lt;&lt; std::endl;

 return 0;
}
</code></pre>

blocks|key|1738463|text|使用此函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1738464|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());
}|code-block|syntax|javascript|1738465|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Use this function:

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

blocks|key|1738539|text|使用boost::algorithm::ends_with+(例如参见http://www.boost.org/doc/libs/1_34_0/doc/html/boost/algorithm/ends_with.html+)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1738540|#include+<boost/algorithm/string/predicate.hpp>

//+works+with+const+char*+
assert(boost::algorithm::ends_with("mystring",+"ing"));

//+also+works+with+std::string
std::string+haystack("mystring");
std::string+needle("ing");
assert(boost::algorithm::ends_with(haystack,+needle));

std::string+haystack2("ng");
assert(!+boost::algorithm::ends_with(haystack2,+needle));|code-block|syntax|javascript|1738541|entityMap|0|LINK|mutability|MUTABLE|url|http://www.boost.org/doc/libs/1_34_0/doc/html/boost/algorithm/ends_with.html^0|2|R|Z|24|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@$9|V|A|W|1|X]]|E|$]]|$1|F|3|G|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|L|$M|$5|N|O|P|E|$Q|R]]]]

Use <code>boost::algorithm::ends_with</code> (see e.g. <a href="http://www.boost.org/doc/libs/1_34_0/doc/html/boost/algorithm/ends_with.html">http://www.boost.org/doc/libs/1_34_0/doc/html/boost/algorithm/ends_with.html</a> ):

<pre><code>#include &lt;boost/algorithm/string/predicate.hpp&gt;

// works with const char* 
assert(boost::algorithm::ends_with("mystring", "ing"));

// also works with std::string
std::string haystack("mystring");
std::string needle("ing");
assert(boost::algorithm::ends_with(haystack, needle));

std::string haystack2("ng");
assert(! boost::algorithm::ends_with(haystack2, needle));
</code></pre>

blocks|key|3848214|text|请注意，从c%2B%2B20+std::string开始，最终将提供starts_with和ends_with。看起来c%2B%2B中的by+c%2B%2B30字符串可能最终会变得有用，如果你不是在遥远的将来阅读这篇文章，你可以在C%2B%2B17中使用这些开头和/+Seems：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|3848215|#if+__cplusplus+>=+201703L+//+C%2B%2B17+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%2B%2B17|code-block|syntax|javascript|3848216|如果您坚持使用较旧的C%2B%2B，则可以使用以下方法：|3848217|#if+__cplusplus+<+201703L+//+pre+C%2B%2B17
#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);
}|3848218|和一些额外的帮助程序重载：|3848219|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));
}
#endif|3848220|在国际海事组织，c%2B%2B字符串显然是功能失调的，并不是为了在现实世界的代码中使用的。但至少有希望这种情况会变得更好。|3848221|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/C%252B%252B20|1|http://en.cppreference.com/w/cpp/string/basic_string/starts_with|2|http://en.cppreference.com/w/cpp/string/basic_string/ends_with^0|5|5|0|U|B|1|16|9|2|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]|$A|18|B|19|1|1A]|$A|1B|B|1C|1|1D]]|C|$]]|$1|D|3|E|5|F|7|1E|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|1F|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1G|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|1I|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|C|$]]|$1|S|3|-4|5|6|7|1K|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|11]]|12|$5|V|W|X|C|$Y|13]]]]

Note, that starting from <a href="https://en.wikipedia.org/wiki/C%2B%2B20" rel="noreferrer">c++20</a> std::string will finally provide <a href="http://en.cppreference.com/w/cpp/string/basic_string/starts_with" rel="noreferrer">starts_with</a> and <a href="http://en.cppreference.com/w/cpp/string/basic_string/ends_with" rel="noreferrer">ends_with</a>. Seems like there is a chance that by c++30 strings in c++ might finally become usable, if you aren't reading this from distant future, you can use these startsWith/endsWith with C++17:
<pre><code>#if __cplusplus &gt;= 201703L // C++17 and later 
#include &lt;string_view&gt;

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

static bool startsWith(std::string_view str, std::string_view prefix)
{
 return str.size() &gt;= prefix.size() &amp;&amp; 0 == str.compare(0, prefix.size(), prefix);
}
#endif // C++17
</code></pre>
If you are stuck with older C++, you may use these:
<pre><code>#if __cplusplus &lt; 201703L // pre C++17
#include &lt;string&gt;

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

static bool startsWith(const std::string&amp; str, const std::string&amp; prefix)
{
 return str.size() &gt;= prefix.size() &amp;&amp; 0 == str.compare(0, prefix.size(), prefix);
}
</code></pre>
and some extra helper overloads:
<pre><code>static bool endsWith(const std::string&amp; str, const char* suffix, unsigned suffixLen)
{
 return str.size() &gt;= suffixLen &amp;&amp; 0 == str.compare(str.size()-suffixLen, suffixLen, suffix, suffixLen);
}

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

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

static bool startsWith(const std::string&amp; str, const char* prefix)
{
 return startsWith(str, prefix, std::string::traits_type::length(prefix));
}
#endif
</code></pre>
IMO, c++ strings are clearly dysfunctional, and weren't made to be used in real world code. But there is a hope that this will get better at least.

blocks|key|5265675|text|当使用std::mismatch方法从两个字符串的末尾向后迭代时，可以实现此目的：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5265676|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()+);|code-block|syntax|javascript|5265677|entityMap^0|3|D|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

The <code>std::mismatch</code> method can serve this purpose when used to backwards iterate from the end of both strings:

<pre><code>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() );
</code></pre>

blocks|key|3848102|text|在我看来，最简单的C%2B%2B解决方案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3848103|bool+endsWith(const+std::string&+s,+const+std::string&+suffix)
{
++++return+s.rfind(suffix)+==+std::abs(s.size()-suffix.size());
}|code-block|syntax|javascript|3848104|警告：如果匹配失败，这将在放弃之前向后搜索整个字符串，因此可能会浪费很多周期。|offset|length|style|BOLD|3848105|entityMap^0|0|0|0|3|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

In my opinion simplest, C++ solution is:
<pre><code>bool endsWith(const std::string&amp; s, const std::string&amp; suffix)
{
 return s.rfind(suffix) == std::abs(s.size()-suffix.size());
}
</code></pre>
Warning: If the match fails, this will search the entire string backwards before giving up, and thus potentially waste a lot of cycles.

blocks|key|1738399|text|假设a是一个字符串，并对要查找的字符串执行b操作。使用a.substr获取a的最后n个字符，并将它们与b进行比较(其中n是b的长度)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1738400|或者使用std::equal+(包括<algorithm>)|1738401|例如：|1738402|bool+EndsWith(const+string&+a,+const+string&+b)+{
++++if+(b.size()+>+a.size())+return+false;
++++return+std::equal(a.begin()+%2B+a.size()+-+b.size(),+a.end(),+b.begin());
}|code-block|syntax|javascript|1738403|entityMap^0|2|1|L|1|R|8|11|1|1P|1|0|4|A|I|B|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]|$9|X|A|Y|B|C]|$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|11|8|@$9|12|A|13|B|C]|$9|14|A|15|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|16|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|17|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|18|8|@]|D|@]|E|$]]]|P|$]]

Let <code>a</code> be a string and <code>b</code> the string you look for. Use <code>a.substr</code> to get the last n characters of <code>a</code> and compare them to b (where n is the length of <code>b</code>)

Or use <code>std::equal</code> (include <code>&lt;algorithm&gt;</code>)

Ex:

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

blocks|key|1738735|text|让我用不区分大小写的版本(online+demo)扩展Joseph's+solution|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1738736|#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);
++++++++}
++++);
}|code-block|syntax|javascript|1738737|entityMap|0|LINK|mutability|MUTABLE|url|http://coliru.stacked-crooked.com/a/2080ca594951bae9|1|https://stackoverflow.com/a/2072890^0|D|B|0|R|H|1|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|E|5|F|7|Z|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]|Q|$5|L|M|N|C|$O|R]]]]

Let me extend <a href="https://stackoverflow.com/a/2072890">Joseph's solution</a> with the case insensitive version (<a href="http://coliru.stacked-crooked.com/a/2080ca594951bae9" rel="nofollow noreferrer">online demo</a>)
<pre><code>#include &lt;string&gt;
#include &lt;cctype&gt;

static bool EndsWithCaseInsensitive(const std::string&amp; value, const std::string&amp; ending) {
 if (ending.size() &gt; 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);
 }
 );
}
</code></pre>

blocks|key|1487616|text|您可以使用string::rfind|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1487617|基于注释的完整示例：|1487618|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;
}|code-block|syntax|javascript|1487619|entityMap|0|LINK|mutability|MUTABLE|url|http://www.cplusplus.com/reference/string/string/rfind/^0|5|D|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@$A|T|B|U|1|V]]|C|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|X|8|@]|9|@]|C|$I|J]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|C|$]]]|L|$M|$5|N|O|P|C|$Q|R]]]]

you can use <a href="http://www.cplusplus.com/reference/string/string/rfind/" rel="noreferrer">string::rfind</a>

The full Example based on comments:

<pre><code>bool EndsWith(string &amp;str, string&amp; key)
{
size_t keylen = key.length();
size_t strlen = str.length();

if(keylen =&lt; strlen)
 return string::npos != str.rfind(key,strlen - keylen, keylen);
else return false;
}
</code></pre>

blocks|key|5265926|text|使用<algorithms>中的std::equal算法进行反向迭代：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5265927|std::string+LogExt+=+".log";
if+(std::equal(LogExt.rbegin(),+LogExt.rend(),+filename.rbegin()))+{
+++…
}|code-block|syntax|javascript|5265928|entityMap^0|2|C|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Use std::equal algorithm from <code>&lt;algorithms&gt;</code> with reverse iteration:

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

blocks|key|1487663|text|和上面一样，下面是我的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1487664|+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());
++}|code-block|syntax|javascript|1487665|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

the very same as above, here is my solution

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

blocks|key|1738623|text|使用以下命令检查字符串是否具有后缀：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1738624|/*
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+%2B+strLen+-+suffixLen,+suffix,+suffixLen)+==+0;
++}
++return+0;
}|code-block|syntax|javascript|1738625|entityMap^0|8|3|F|2|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Check if str has suffix, using below:

<pre><code>/*
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 &lt;= strLen) {
 return strncmp(str + strLen - suffixLen, suffix, suffixLen) == 0;
 }
 return 0;
}
</code></pre>

blocks|key|3848128|text|关于Grzegorz+Bazior的回应。我使用了这个实现，但原来的实现有错误(如果我比较"..“，则返回true。使用".so")。我建议修改函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3848129|bool+endsWith(const+string&+s,+const+string&+suffix)
{
++++return+s.size()+>=+suffix.size()+&&+s.rfind(suffix)+==+(s.size()-suffix.size());
}|code-block|syntax|javascript|3848130|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Regarding Grzegorz Bazior response. I used this implementation, but original one has bug (returns true if I compare ".." with ".so").
I propose modified function:

<pre><code>bool endsWith(const string&amp; s, const string&amp; suffix)
{
 return s.size() &gt;= suffix.size() &amp;&amp; s.rfind(suffix) == (s.size()-suffix.size());
}
</code></pre>

blocks|key|1738636|text|我认为发布一个不使用任何库函数的原始解决方案是有意义的……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1738637|//+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();+%2B%2Bi)+{
++++++++if+(suffix[i]+!=+str[delta+%2B+i])+return+false;
++++}
++++return+true;
}|code-block|syntax|javascript|1738638|添加一个简单的std::tolower，我们可以使大小写不敏感|offset|length|style|CODE|1738639|//+Checks+whether+`str'+ends+with+`suffix'+ignoring+case
bool+endsWithIgnoreCase(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();+%2B%2Bi)+{
++++++++if+(std::tolower(suffix[i])+!=+std::tolower(str[delta+%2B+i]))+return+false;
++++}
++++return+true;
}|1738640|entityMap^0|0|0|7|C|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

I thought it makes sense to post a raw solution that doesn't use any library functions...

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

Adding a simple <code>std::tolower</code> we can make this case insensitive

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

blocks|key|5265917|text|另一种选择是使用正则表达式。下面的代码使搜索不区分大小写：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5265918|bool+endsWithIgnoreCase(const+std::string&+str,+const+std::string&+suffix)+{
++return+std::regex_search(str,
+++++std::regex(std::string(suffix)+%2B+"$",+std::regex_constants::icase));
}|code-block|syntax|javascript|5265919|可能效率不是很高，但很容易实现。|5265920|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

another option is to use regex. The following code makes the search insensitive to upper/lower case:

<pre><code>bool endsWithIgnoreCase(const std::string&amp; str, const std::string&amp; suffix) {
 return std::regex_search(str,
 std::regex(std::string(suffix) + "$", std::regex_constants::icase));
}
</code></pre>

probably not so efficient, but easy to implement.

blocks|key|1492155|text|对于类似的“startWith”-problem，我找到了一个很好的答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1492156|How+do+I+check+if+a+C%2B%2B+std::string+starts+with+a+certain+string,+and+convert+a+substring+to+an+int?|offset|length|1492157|您可以采用仅在字符串的最后位置进行搜索的解决方案：|1492158|bool+endsWith(const+std::string&+stack,+const+std::string&+needle)+{
++++return+stack.find(needle,+stack.size()+-+needle.size())+!=+std::string::npos;
}|code-block|syntax|javascript|1492159|这样你就可以让它变得简短、快速，使用标准的c%2B%2B并使其具有可读性。|1492160|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1878001/how-do-i-check-if-a-c-stdstring-starts-with-a-certain-string-and-convert-a^0|0|0|2S|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@$D|Y|E|Z|1|10]]|A|$]]|$1|F|3|G|5|6|7|11|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

Found this nice answer to the similar "startWith"-problem:

<a href="https://stackoverflow.com/questions/1878001/how-do-i-check-if-a-c-stdstring-starts-with-a-certain-string-and-convert-a">How do I check if a C++ std::string starts with a certain string, and convert a substring to an int?</a>

You can adopt the solution to only search at the last place in the string:

<pre class="lang-cpp prettyprint-override"><code>bool endsWith(const std::string&amp; stack, const std::string&amp; needle) {
 return stack.find(needle, stack.size() - needle.size()) != std::string::npos;
}
</code></pre>

This way you can make it short, fast, use standard c++ and make it readable.

blocks|key|3848407|text|如果像我一样，需要使用endsWith检查文件扩展名，可以使用std::filesystem库：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3848408|std::filesystem::path("/foo/bar.txt").extension()+==+".txt"|code-block|syntax|javascript|3848409|entityMap^0|V|F|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

If, like me, you need endsWith to check a file extension, you can use the <code>std::filesystem</code> library:
<pre><code>std::filesystem::path(&quot;/foo/bar.txt&quot;).extension() == &quot;.txt&quot;
</code></pre>

blocks|key|1492097|text|如果你像我一样不喜欢C%2B%2B纯粹主义，这里有一个旧的skool混血儿。当字符串多于几个字符时会有一些优势，因为大多数memcmp实现都会尽可能地比较机器单词。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1492098|您需要控制字符集。例如，如果这种方法与utf-8或wchar类型一起使用，就会有一些缺点，因为它不支持字符映射-例如，当两个或更多字符为logically+identical时。|1492099|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()+%2B+valueSize+-+suffixSize;

++++return+memcmp(valuePtr,+suffix.data(),+suffixSize)+==+0;
}|code-block|syntax|javascript|1492100|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/Duplicate_characters_in_Unicode^0|1L|6|0|1W|J|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|H|3|I|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

If you're like me and no so into C++ purism, here's an old skool hybrid. There's some advantage when strings are more than a handful of characters, as most <code>memcmp</code> implementations compare machine words when possible.

You need to be in control of the character set. For example, if this approach is used with utf-8 or wchar type, there's some disadvantage as it won't support character mapping - e.g., when two or more characters are <a href="https://en.wikipedia.org/wiki/Duplicate_characters_in_Unicode" rel="nofollow noreferrer">logically identical</a>.

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

 if (prefixSize &gt; valueSize)
 {
 return false;
 }

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


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

 if (suffixSize &gt; valueSize)
 {
 return false;
 }

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

 return memcmp(valuePtr, suffix.data(), suffixSize) == 0;
}
</code></pre>

blocks|key|3848359|text|我的两点意见：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3848360|bool+endsWith(std::string+str,+std::string+suffix)
{
+++return+str.find(suffix,+str.size()+-+suffix.size())+!=+string::npos;
}|code-block|syntax|javascript|3848361|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

My two cents:

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

blocks|key|1487822|text|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;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1487823|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

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

 if(totalSize &lt; suffixSize) {
 return false;
 }

 return str.compare(totalSize - suffixSize, suffixSize, suffix) == 0;
}
</code></pre>

blocks|key|1738963|text|bool+EndsWith(const+std::string&+data,+const+std::string&+suffix)
{
++++return+data.find(suffix,+data.size()+-+suffix.size())+!=+std::string::npos;
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1738964|测试|unstyled|offset|length|style|BOLD|1738965|#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;
}|1738966|输出|1738967|0+
1+
1+
1+|1738968|entityMap^0|0|0|2|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@$G|U|H|V|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$B|C]]|$1|M|3|N|5|F|7|X|8|@$G|Y|H|Z|I|J]]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$B|C]]|$1|Q|3|-4|5|F|7|11|8|@]|9|@]|A|$]]]|R|$]]

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

</code></pre>
Tests
<pre><code>#include &lt;iostream&gt;
int main()
{
 cout &lt;&lt; EndsWith(u8&quot;o!hello!1&quot;, u8&quot;o!&quot;) &lt;&lt; endl; 
 cout &lt;&lt; EndsWith(u8&quot;o!hello!&quot;, u8&quot;o!&quot;) &lt;&lt; endl; 
 cout &lt;&lt; EndsWith(u8&quot;hello!&quot;, u8&quot;o!&quot;) &lt;&lt; endl; 
 cout &lt;&lt; EndsWith(u8&quot;o!hello!o!&quot;, u8&quot;o!&quot;) &lt;&lt; endl; 
 return 0;
}
</code></pre>
Output
<pre><code>0 
1 
1 
1 
</code></pre>

How can I find out if a string ends with another string in C++?

Find out if string ends with another string in C++

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

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

问查看C++中的字符串是否以另一个字符串结尾
EN

回答 21

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问查看C++中的字符串是否以另一个字符串结尾EN

回答 21

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问查看C++中的字符串是否以另一个字符串结尾
EN