Le typedef le plus important est le premier défini de la classe, name_check. Ce type est un type de fonction qui permettra de vérifier la validité d'un chemin. iterator définit quant à lui le type des itérateurs qu'on peut utiliser.

Aucun destructeur n'est défini, en revanche, les constructeurs sont parfois en double. En fait, ils peuvent prendre en entrée rien du tout - le constructeur par défaut -, ou un const char * ou un const string&, accompagné ou non d'une fonction de vérification de type name_check.

Les opérateurs d'ajouts utilisent l'opérateur « / », qui est le standard choisi par boost comme caractère de séparation, il y a donc une logique. Il existe donc operator/ et operator/= qui permettent d'ajouter un chemin à une instance de classe.

Trois fonctions de conversion existent. string() retourne une chaîne de caractères représentant le chemin que l'instance décrit avec le caractère « / » comme séparateur. native_file_string() et native_directory_string() retourne une chaîne de caractères en utilisant la manière native à l'OS de représenter un chemin de fichier ou de dossier.

La normalisation d'une instance de classe path est appelée à l'aide de la fonction normalize() qui retire récursivement les sous-chaînes de type « foo/../ ».

La première fonction est root_path() qui retourne en fait la concaténation du résultat de deux autres fonctions, root_name() et root_directory(). La première de ces fonctions retourne le premier élément du chemin si celui-ci est une racine - par exemple « c: » sous Windows - tandis que la deuxième retourne « / » si l'instance de path contient une racine. La fonction relative_path() retourne la portion relative de l'instance; que la fonction leaf() retourne le dernier élément de l'instance tandis que branch_path() permet tout simplement de récupérer le chemin contenu dans l'instance sans le dernier élément, celui retourné par leaf().

En ce qui concerne les itérateurs, les deux fonctions classiques, begin() et end(), sont fournies.

Les premières fonctions importantes sont empty(), retournant true si le chemin est vide, is_complete() retournant true si le chemin est absolu. D'autres fonctions sont disponibles, has_root_path() retourne true si has_root_name() retourne true - lorsqu'il y a une racine dans l'instance de la classe - ou si has_root_directory() retourne true - si root_directory() n'est pas vide -. De même pour has_relative_path(), has_leaf() et has_branch_path() retournant true si l'instance a un chemin relatif, un dernier élément ou un chemin sans le dernier élément non vide.

Comme indiqué précédemment, on peut spécifier une fonction de vérification de validité du chemin. default_name_check_writable() retourne true si aucune fonction de test n'a été spécifiée quand default_name_check() permet de la spécifier, mais une seule fois. La fonction default_name_check() retourne la fonction de vérification sélectionnée.

Les opérateurs de comparaison classiques ont été définis, comme operator==, operator!=, operator==, operator<, operator<=, operator> et operator>=. Ces comparaisons utilisent uniquement l'ordre lexicographique.

Deux fonctions surchargées operator/ permettent de concaténer un const char* ou un const string& avec une instance de classe path. Enfin, des fonctions permettent de vérifier la conformité d'un chemin stocké dans un string, comme portable_posix_name(), windows_name(), portable_name(), portable_directory_name(), portable_file_name(), no_check(), native() qui retournent true lorsque le chemin est compatible POSIX, Windows, les deux, décrit un dossier sans « . », un nom de fichier avec un « . », dans tous les cas, ou lorsque le chemin est valide sous le système d'exploitation utilisé.

class directory_iterator
{
public:
  typedef path                     value_type;
  typedef std::ptrdiff_t           difference_type;
  typedef const path *             pointer;
  typedef const path &             reference;
  typedef std::input_iterator_tag  iterator_category;

  directory_iterator();
  explicit directory_iterator( const path & directory_ph );

  // Autres fonctions pour un itérateur
  // ...
};

La classe directory_iterator est, comme son nom l'indique, un itérateur. Il est de catégorie std::input_iterator_tag, et donc définit toutes les fonctions usuelles d'un itérateur – comparaison, incrémentation, déréférencement… –, l'objet pointé étant de type path.

bool exists( const path & ph );
bool symbolic_link_exists( const path & ph );
bool is_directory( const path & ph );
bool is_empty( const path & ph );
bool equivalent( const path & ph1, const path & ph2 );

boost::intmax_t file_size( const path & ph );

std::time_t last_write_time( const path & ph );
void last_write_time( const path & ph, std::time_t new_time );

bool create_directory( const path & directory_ph );
bool remove( const path & ph );
unsigned long remove_all( const path & ph );
void rename( const path & from_path,
             const path & to_path );
void copy_file( const path & source_file,
                const path & target_file );

const path & initial_path();
path current_path();
path complete( const path & ph,
               const path & base = initial_path() );
path system_complete( const path & ph );

Les premières fonctions utiles permettent de connaître l'état d'une instance de path. Par exemple, exists() teste l'existence d'un fichier/dossier, symbolic_link_exists() si le chemin est un lien symbolique, is_directory() si le chemin est un dossier, is_empty() indique si le fichier ou le dossier est vide, enfin is_equivalent() indique si deux chemins sont équivalents.

file_size() retourne la taille d'un fichier, quand last_write_time() retourne le temps de la dernière écriture sur le fichier. Une fonction surchargée de last_write_time() permet de mettre à jour ce temps.

D'autres fonctions dont utiles pour modifier l'arborescence. Par exemple, create_directory() crée un nouveau dossier, remove() détruit un chemin - et retourne true si le chemin existait -, remove_all() détruit tous les dossiers et fichiers contenus dans un chemin, et retourne le nombre d'éléments détruits. Enfin, copy_file() permet de copier un fichier et rename() de renommer un chemin.

Enfin, initial_path() retourne le contenu de current_path() lors de la première invocation en stockant ce résultat, current_path() retournant le chemin courant tel que l'OS le connaît, complete() permet de compléter un chemin relatif et system_complete() résout un chemin relatif comme le ferait l'OS.