Я просто прочитал несколько рекомендаций по использованию
std::string s = get_string();
std::string t = another_string();
if( !s.compare(t) )
{
вместо
if( s == t )
{
Я почти всегда использую последний, потому что я привык к нему, и он чувствует себя естественным, более читаемым. Я даже не знал, что существует отдельная функция сравнения. Чтобы быть более точным, я думал, что == будет ссылаться на compare().
В чем отличия? В каких контекстах должен быть один путь к другому?
Я рассматриваю только те случаи, когда мне нужно знать, является ли строка тем же значением, что и другая строка.
Это то, что стандарт должен сказать об operator==
21.4.8.2 оператор ==
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.
Похоже, нет большой разницы!
std::string:: compare() возвращает int:
s и t равны,s меньше t,s больше, чем t.Если вы хотите, чтобы ваш первый фрагмент кода был эквивалентен второму, он должен действительно читать:
if (!s.compare(t)) {
// 's' and 't' are equal.
}
Оператор равенства только проверяет равенство (отсюда и его имя) и возвращает a bool.
Чтобы уточнить варианты использования, compare() может быть полезна, если вам интересно, как две строки связаны друг с другом (меньше или больше), когда они случаются иначе. PlasmaHH справедливо упоминает деревья, а также может быть, скажем, алгоритмом вставки строк, целью которого является сохранение сортировки контейнера, алгоритм дихотомического поиска для вышеупомянутого контейнера и т.д.
EDIT: Как отмечает Стив Джессоп в комментариях, compare() наиболее полезен для быстрых алгоритмов сортировки и бинарного поиска. Естественные виды и дихотомические поиски могут быть реализованы только с std:: less.
compare имеет перегрузки для сравнения подстрок. Если вы сравниваете целые строки, вы должны просто использовать оператор == (и вызывает ли он compare или нет, в значительной степени не имеет значения).
Внутренне, string:: operator ==() использует string:: compare(). Пожалуйста, обратитесь к: CPlusPlus - String:: Operator ==()
Я написал небольшое приложение для сравнения производительности, и, судя по всему, если вы компилируете и запускаете свой код в среде отладки, String:: compare() немного быстрее, чем string:: operator ==(). Однако, если вы компилируете и запускаете свой код в среде Release, оба они почти одинаковы.
FYI, я провел 1000 000 итераций, чтобы придумать такой вывод.
Чтобы доказать, что в среде отладки строка:: compare выполняется быстрее, я пошел в сборку и вот код:
DEBUG BUILD
строка:: оператор ==()
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)
строка:: сравнить()
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 ==() он должен выполнять дополнительные операции (добавить esp, 8 и movzx edx, al)
RELEASE BUILD
строка:: оператор ==()
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)
строка:: сравнить()
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() эквивалентен strcmp(). == - простая проверка равенства. compare() поэтому возвращает int, == является логическим.
compare() вернет false (ну, 0), если строки равны.
Так что не делайте замену другим для другого.
Используйте то, что делает код более удобочитаемым.
Если вы просто хотите проверить равенство строк, используйте оператор ==. Определение того, являются ли две строки равными, проще, чем найти порядок (что дает compare()), поэтому в вашем случае может быть лучше работать с оператором равенства.
Более длинный ответ: API предоставляет метод проверки равенства строк и метода проверки порядка строк. Вам нужно равенство строк, поэтому используйте оператор равенства (чтобы ваши ожидания и ожидания редакторов библиотеки совпадали.) Если производительность важна, вам может потребоваться проверить оба метода и найти самый быстрый.
Одна вещь, которая здесь не рассматривается, заключается в том, что это зависит от того, будем ли мы сравнивать строку с строкой 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; }
В отладчике Visual Studio 2012 только правильная работа при проверке строки пуста или нет:
strcmp(somestring.c_str(),"")==0
return true.
somestring.compare("")
return 1 и
somestring==""
Возврат: ни один оператор "==" не соответствует этим операндам.
somestring.c_str()==""
return: Произошла неуказанная ошибка.
Предположим рассмотреть две строки s и t.
Дайте им некоторые значения.
Когда вы сравниваете их с помощью (s == t), он возвращает логическое значение (true или false, 1 или 0).
Но когда вы сравниваете использование s.compare(t), выражение возвращает значение
(i) 0 - если s и t равны
(ii) < 0 - либо если значение первого несогласованного символа в s меньше, чем значение t или длина s меньше, чем значение t.
(iii) > 0 - либо если значение первого несогласованного символа в t меньше, чем значение s или длина t меньше, чем значение s.