std::filesystem::path::compare

int compare( const path& p ) const noexcept;	(1)	(начиная с C++17)
int compare( const string_type& str ) const; int compare( std::basic_string_view<value_type> str ) const;	(2)	(начиная с C++17)
int compare( const value_type* s ) const;	(3)	(начиная с C++17)

Сравнивает лексические представления пути и другого пути.

1) Если root_name().native().compare(p.root_name().native()) не равен нулю, возвращает это значение.

В противном случае, если has_root_directory() != p.has_root_directory(), возвращает значение меньше нуля, если has_root_directory() имеет значение false, и значение больше нуля в противном случае.

В противном случае возвращает значение меньше, равное или больше 0, если относительная часть пути (relative_path()) соответственно лексикографически меньше, равна или больше относительной части p (p.relative_path()). Сравнение выполняется поэлементно, как если бы оба пути обходились от begin() до end() и для каждого элемента сравнивался результат native().

2) Эквивалентно compare(path(str)).

3) Эквивалентно compare(path(s)).

Параметры

p	-	путь для сравнения
str	-	строка или представление строки, обозначающие путь для сравнения
s	-	строка с завершающим нулём, обозначающая путь для сравнения

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

Значение меньше 0, если путь лексикографически меньше заданного пути.

Значение, равное 0, если путь лексикографически равен заданному пути.

Значение больше 0, если путь лексикографически больше заданного пути.

Исключения

2,3) Может выбрасывать исключения, определяемые реализацией.

Примечания

Для двусторонних сравнений могут быть более подходящими бинарные операторы.

Пример

#include <filesystem>
#include <iostream>
#include <string_view>
namespace fs = std::filesystem;

void demo(fs::path p1, fs::path p2, std::string_view msg)
{
    std::cout << p1;
    const int rc = p1.compare(p2); 
    if (rc < 0)
        std::cout << " < ";
    else if (rc > 0)
        std::cout << " > ";
    else
        std::cout << " == ";
    std::cout << p2 << " \t: " << msg << '\n';
}

int main()
{
    demo("/a/b/", "/a/b/", "simple");
    demo("/a/b/", "/a/b/c", "simple");
    demo("/a/b/../b", "/a/b", "no canonical conversion");
    demo("/a/b", "/a/b/.", "no canonical conversion");
    demo("/a/b/", "a/c", "absolute paths order after relative ones");
}

Вывод:

"/a/b/" == "/a/b/"      : simple
"/a/b/" < "/a/b/c"        : simple
"/a/b/../b" > "/a/b"        : no canonical conversion
"/a/b" < "/a/b/."        : no canonical conversion
"/a/b/" > "a/c"                : absolute paths order after relative ones

Сведения об исправлениях ошибок

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

DR	Применён к	Опубликованное поведение	Правильное поведение
LWG 2936	C++17	непосредственно сравнивались все элементы пути	корневое имя и корневой каталог обрабатываются отдельно

См. также

operator==operator!=operator<operator<=operator>operator>=operator<=>

(C++17)(C++17)(до C++20)(C++17)(до C++20)(C++17)(до C++20)(C++17)(до C++20)(C++17)(до C++20)(C++20)

лексикографически сравнивает два пути
(функция)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/filesystem/path/compare