std::basic_string<CharT,Traits,Allocator>::compare

int compare( const basic_string& str ) const;

int compare( size_type pos1, size_type count1,
             const basic_string& str ) const;

int compare( size_type pos1, size_type count1,
             const basic_string& str,
             size_type pos2, size_type count2 ) const;

int compare( size_type pos1, size_type count1,
             const basic_string& str,
             size_type pos2, size_type count2 = npos ) const;

int compare( const CharT* s ) const;

int compare( size_type pos1, size_type count1,
             const CharT* s ) const;

int compare( size_type pos1, size_type count1,
             const CharT* s, size_type count2 ) const;

template< class StringViewLike >
int compare( const StringViewLike& t ) const noexcept(/* see below */);

template< class StringViewLike >
int compare( size_type pos1, size_type count1,
             const StringViewLike& t ) const;

template< class StringViewLike >
int compare( size_type pos1, size_type count1,
             const StringViewLike& t,
             size_type pos2, size_type count2 = npos) const;

Сравнивает две последовательности символов.

Последовательность символов, состоящая из count1 символов, начиная с data1, сравнивается с последовательностью символов, состоящей из count2 символов, начиная с data2, следующим образом:

• Сначала вычисляется количество символов для сравнения, как если бы с помощью size_type rlen = std::min(count1, count2).
• Затем последовательности сравниваются вызовом Traits::compare(data1, data2, rlen). Для стандартных строк эта функция выполняет лексикографическое сравнение посимвольно. Если результат равен нулю (последовательности символов пока равны), то их размеры сравниваются следующим образом:

Параметры

Возвращаемое значение

• Отрицательное значение, если * this предшествует последовательности символов, заданной аргументами, в лексикографическом порядке.
• Ноль, если обе последовательности символов эквивалентны.
• Положительное значение, если * this следует после последовательности символов, заданной аргументами, в лексикографическом порядке.

Исключения

Перегрузки, принимающие параметры с именами pos1 или pos2 выбрасывают std::out_of_range если аргумент находится вне допустимого диапазона.

Если по какой-либо причине возникает исключение, эта функция не оказывает никакого эффекта ( гарантия строгой безопасности исключений ).

Возможная реализация

template<class CharT, class Traits, class Alloc>
int std::basic_string<CharT, Traits, Alloc>::compare
    (const std::basic_string& s) const noexcept
{
    size_type lhs_sz = size();
    size_type rhs_sz = s.size();
    int result = traits_type::compare(data(), s.data(), std::min(lhs_sz, rhs_sz));
    if (result != 0)
        return result;
    if (lhs_sz < rhs_sz)
        return -1;
    if (lhs_sz > rhs_sz)
        return 1;
    return 0;
}

Примечания

Для ситуаций, когда трёхстороннее сравнение не требуется, std::basic_string предоставляет обычные операторы отношения ( < , <= , == , > , и т.д.).

По умолчанию (с параметрами по умолчанию std::char_traits ) данная функция не зависит от локали. Смотрите std::collate::compare для локале-зависимого трёхстороннего сравнения строк.

Пример

#include <cassert>
#include <iomanip>
#include <iostream>
#include <string>
#include <string_view>
void print_compare_result(std::string_view str1,
                          std::string_view str2,
                          int compare_result)
{
    if (compare_result < 0)
        std::cout << std::quoted(str1) << " идет перед "
                  << std::quoted(str2) << ".\n";
    else if (compare_result > 0)
        std::cout << std::quoted(str2) << " идет перед "
                  << std::quoted(str1) << ".\n";
    else
        std::cout << std::quoted(str1) << " и "
                  << std::quoted(str2) << " одинаковы.\n";
}
int main()
{
    std::string batman{"Batman"};
    std::string superman{"Superman"};
    int compare_result{0};
    // 1) Сравнение с другой строкой
    compare_result = batman.compare(superman);
    std::cout << "1) ";
    print_compare_result("Batman", "Superman", compare_result);
    // 2) Сравнение подстроки с другой строкой
    compare_result = batman.compare(3, 3, superman);
    std::cout << "2) ";
    print_compare_result("man", "Superman", compare_result);
    // 3) Сравнение подстроки с другой подстрокой
    compare_result = batman.compare(3, 3, superman, 5, 3);
    std::cout << "3) ";
    print_compare_result("man", "man", compare_result);
    // Сравнение подстроки с другой подстрокой
    // по умолчанию до конца другой строки
    assert(compare_result == batman.compare(3, 3, superman, 5));
    // 4) Сравнение с указателем на char
    compare_result = batman.compare("Superman");
    std::cout << "4) ";
    print_compare_result("Batman", "Superman", compare_result);
    // 5) Сравнение подстроки с указателем на char
    compare_result = batman.compare(3, 3, "Superman");
    std::cout << "5) ";
    print_compare_result("man", "Superman", compare_result);
    // 6) Сравнение подстроки с подстрокой указателя на char
    compare_result = batman.compare(0, 3, "Superman", 5);
    std::cout << "6) ";
    print_compare_result("Bat", "Super", compare_result);
}

1) "Batman" идет перед "Superman".
2) "Superman" идет перед "man".
3) "man" и "man" одинаковы.
4) "Batman" идет перед "Superman".
5) "Superman" идет перед "man".
6) "Bat" идет перед "Super".

Отчеты о дефектах

Следующие отчеты об изменениях поведения, влияющие на дефекты, были применены ретроактивно к ранее опубликованным стандартам C++.

См. также