std::filesystem::path::compare

int compare( const path& p ) const noexcept;	(1)	(since C++17)
int compare( const string_type& str ) const; int compare( std::basic_string_view<value_type> str ) const;	(2)	(since C++17)
int compare( const value_type* s ) const;	(3)	(since 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/w/cpp/filesystem/path/compare