我刚刚阅读了一些关于使用
std::string s = get_string();
std::string t = another_string();
if( !s.compare(t) )
{
if( s == t )
{
这是标准对operator==的说明：
21.4.8.2 operator==
template<class charT, class traits, class Allocator>
bool operator==(const basic_string<charT,traits,Allocator>& lhs,
const basic_string<charT,traits,Allocator>& rhs) noexcept;
返回值：lhs.compare(rhs) == 0。
!s.compare(t) 和 s == t 将返回相同的值，但是 compare 函数提供了比s == t更多的信息，当您只关心字符串是否不同而不关心它们不同的方式时，s == t 更易读。 - cdgrahamstd::string::compare()函数返回一个int值:
s和t相等，则返回零。s小于t，则返回小于零的值。s大于t，则返回大于零的值。如果您想让第一个代码片段与第二个代码片段等效，则应该实际上这样编写:
if (!s.compare(t)) {
// 's' and 't' are equal.
}
bool。compare()可能很有用，如果您对它们之间的关系（较小或较大）感兴趣。PlasmaHH正确地提到了树，它也可以是一个字符串插入算法，旨在保持容器排序，对于上述容器的二分查找算法等等。
编辑：正如Steve Jessop在评论中指出的那样，compare()对于快速排序和二分搜索算法最有用。自然排序和二分搜索可以仅使用std::less实现。std::less，在这种情况下也是全序）而不是三路比较器。compare() 适用于基于 std::qsort 和 std::bsearch 的操作，而不是基于 std::sort 和 std::lower_bound 的操作。 - Steve Jessop在内部， string::operator==() 使用了 string::compare()。请参考：CPlusPlus - string::operator==()
我写了一个小程序来比较性能，显然如果您在调试环境下编译和运行代码，string::compare() 比 string::operator==() 稍微快一点。但是如果您在发布环境下编译和运行代码，两者几乎相同。
顺便说一下，我运行了100万次迭代才得出这样的结论。
为了证明为什么在调试环境中 string::compare 更快，我查看了汇编代码：
调试版本
string::operator==()
if (str1 == str2)
00D42A34 lea eax,[str2]
00D42A37 push eax
00D42A38 lea ecx,[str1]
00D42A3B push ecx
00D42A3C call std::operator==<char,std::char_traits<char>,std::allocator<char> > (0D23EECh)
00D42A41 add esp,8
00D42A44 movzx edx,al
00D42A47 test edx,edx
00D42A49 je Algorithm::PerformanceTest::stringComparison_usingEqualOperator1+0C4h (0D42A54h)
string::compare()
if (str1.compare(str2) == 0)
00D424D4 lea eax,[str2]
00D424D7 push eax
00D424D8 lea ecx,[str1]
00D424DB call std::basic_string<char,std::char_traits<char>,std::allocator<char> >::compare (0D23582h)
00D424E0 test eax,eax
00D424E2 jne Algorithm::PerformanceTest::stringComparison_usingCompare1+0BDh (0D424EDh)
你可以看到，在string::operator==()中，需要执行额外的操作(add esp, 8和movzx edx,al)。
发布版本
string::operator==()
if (str1 == str2)
008533F0 cmp dword ptr [ebp-14h],10h
008533F4 lea eax,[str2]
008533F7 push dword ptr [ebp-18h]
008533FA cmovae eax,dword ptr [str2]
008533FE push eax
008533FF push dword ptr [ebp-30h]
00853402 push ecx
00853403 lea ecx,[str1]
00853406 call std::basic_string<char,std::char_traits<char>,std::allocator<char> >::compare (0853B80h)
string::compare()
if (str1.compare(str2) == 0)
00853830 cmp dword ptr [ebp-14h],10h
00853834 lea eax,[str2]
00853837 push dword ptr [ebp-18h]
0085383A cmovae eax,dword ptr [str2]
0085383E push eax
0085383F push dword ptr [ebp-30h]
00853842 push ecx
00853843 lea ecx,[str1]
00853846 call std::basic_string<char,std::char_traits<char>,std::allocator<char> >::compare (0853B80h)
两种汇编代码非常相似，因为编译器执行了优化。
最后，在我看来，性能提升可以忽略不计，因此我真的会把选择权交给开发者决定哪个更好，因为两个都可以达到相同的结果（特别是在发布构建时）。
compare有用于比较子字符串的重载函数。如果您要比较整个字符串，请直接使用==运算符（它是否调用compare函数基本上无关紧要）。
compare() 等同于 strcmp()。 == 是简单的相等检查。 因此，compare() 返回一个 int，== 是布尔类型。
compare()函数在字符串相等时返回false（或者说是0）。
所以不要轻易将它们互换。
使用哪个更容易让代码可读就用哪个。
这里没有涵盖的一件事是，它取决于我们比较字符串与C字符串，C字符串与字符串或字符串与字符串。
一个主要的区别是，在进行比较之前，比较两个字符串的大小相等性被检查，这使得“==”运算符比比较运算符更快。
这是我在g++ Debian 7上看到的比较。
// operator ==
/**
* @brief Test equivalence of two strings.
* @param __lhs First string.
* @param __rhs Second string.
* @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __lhs.compare(__rhs) == 0; }
template<typename _CharT>
inline
typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type
operator==(const basic_string<_CharT>& __lhs,
const basic_string<_CharT>& __rhs)
{ return (__lhs.size() == __rhs.size()
&& !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(),
__lhs.size())); }
/**
* @brief Test equivalence of C string and string.
* @param __lhs C string.
* @param __rhs String.
* @return True if @a __rhs.compare(@a __lhs) == 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const _CharT* __lhs,
const basic_string<_CharT, _Traits, _Alloc>& __rhs)
{ return __rhs.compare(__lhs) == 0; }
/**
* @brief Test equivalence of string and C string.
* @param __lhs String.
* @param __rhs C string.
* @return True if @a __lhs.compare(@a __rhs) == 0. False otherwise.
*/
template<typename _CharT, typename _Traits, typename _Alloc>
inline bool
operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,
const _CharT* __rhs)
{ return __lhs.compare(__rhs) == 0; }
if(x.compare(y) == 0)<- 等号，表示相等。在我看来，只使用!只会使代码难以阅读。 - R. Martinho Fernandescompare如果s小于t则返回-1，如果s大于t则返回+1，而==则返回true/false。非零整数为true，0为false。 - ghchoi