Namespaces
Variants

std::filesystem::path:: compare

From cppreference.net
C++
Filesystem library
Classes
Functions
File types
std::filesystem::path
Member types
Member constants
Member functions
Path decomposition
Non-member functions
(until C++20) (until C++20) (until C++20) (until C++20) (until C++20) (C++20)
Helper classes
int compare ( const path & p ) const noexcept ;
(1) (depuis C++17)
int compare ( const string_type & str ) const ;
int compare ( std:: basic_string_view < value_type > str ) const ;
(2) (depuis C++17)
int compare ( const value_type * s ) const ;
(3) (depuis C++17)

Compare les représentations lexicales du chemin et d'un autre chemin.

1) Si root_name ( ) . native ( ) . compare ( p. root_name ( ) . native ( ) ) est non nul, retourne cette valeur.
Sinon, si has_root_directory ( ) ! = p. has_root_directory ( ) , retourne une valeur inférieure à zéro si has_root_directory() est false et une valeur supérieure à zéro sinon.
Sinon, retourne une valeur inférieure, égale ou supérieure à ​ 0 ​ si la partie relative du chemin ( relative_path() ) est respectivement lexicographiquement inférieure, égale ou supérieure à la partie relative de p ( p. relative_path ( ) ). La comparaison est effectuée élément par élément, comme en itérant les deux chemins de begin() à end() et en comparant le résultat de native() pour chaque élément.
2) Équivalent à compare ( path ( str ) ) .
3) Équivalent à compare ( path ( s ) ) .

Table des matières

Paramètres

p - un chemin à comparer
str - une chaîne ou une vue de chaîne représentant un chemin à comparer
s - une chaîne terminée par un caractère nul représentant un chemin à comparer

Valeur de retour

Une valeur inférieure à ​ 0 ​ si le chemin est lexicographiquement inférieur au chemin donné.

Une valeur égale à ​ 0 ​ si le chemin est lexicographiquement égal au chemin donné.

Une valeur supérieure à ​ 0 ​ si le chemin est lexicographiquement supérieur au chemin donné.

Exceptions

2,3) Peut lever des exceptions définies par l'implémentation.

Notes

Pour les comparaisons bidirectionnelles, les opérateurs binaires peuvent être plus appropriés.

Exemple

Exécuter ce code 
#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");
}

Sortie : 

"/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

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 2936 C++17 comparait tous les éléments de chemin directement nom racine et répertoire racine traités séparément

Voir aussi

(C++17) (C++17) (until C++20) (C++17) (until C++20) (C++17) (until C++20) (C++17) (until C++20) (C++17) (until C++20) (C++20)
compare lexicographiquement deux chemins
(fonction)