std::filesystem::path

1. Чому «шлях як рядок» — це біль

Коли ви лише починаєте програмувати, усе виглядає логічно: шлях — це просто текст, отже, зберігаємо його в std::string. На невеликих завданнях це й справді працює без проблем. Труднощі починаються тоді, коли ви хочете не просто зберігати шлях, а складати його з частин, змінювати розширення, отримувати імʼя файлу, визначати батьківський каталог — і робити це так, щоб код не перетворювався на набір магічних find('.'), rfind('/') і запитань у стилі «чому в мене два слеші поспіль».

Тут зʼявляється важлива думка: шлях — це не просто текст, він має структуру. У ньому є «батьківський каталог», «імʼя файлу», «розширення» та інші корисні деталі. Стандартна бібліотека C++ надає тип std::filesystem::path, який зберігає шлях і вміє виконувати базові операції так, щоб вам не доводилося займатися ручною «рядковою археологією».

Це можна сприймати як перехід від «я зберігаю дату рядком "2026-01-16" і сам розрізаю її за дефісами» до «я зберігаю дату окремим типом». Зі шляхами логіка та сама: щойно ви починаєте різати рядки, одразу потрапляєте в зону ризику.

Невелика таблиця для інтуїції:

"data/" + file

dir / file

substr(rfind('/'))

p.filename()

rfind('.')

p.replace_extension(".bak")

rfind('/')

p.parent_path()

Отже, fs::path не робить вашу програму «справжнім файловим менеджером», але прибирає величезний пласт рутини та помилок.

2. Базові операції з fs::path

Підключаємо <filesystem> і створюємо псевдонім fs

Коли ви вперше бачите std::filesystem::path, рука може потягнутися, щоб закрити ноутбук і піти в монастир. Але ми вчинимо розумніше: підключимо правильний заголовок і заведемо псевдонім простору імен. Це саме той випадок, коли namespace fs = std::filesystem; — не «лінощі друкувати», а справжня турбота про читабельність.

Для початку майже будь-який приклад із цієї лекції починатиметься так:

#include <filesystem>
#include <iostream>

int main() {
    namespace fs = std::filesystem;

    fs::path p{"data/input.txt"};
    std::cout << p.string() << '\n'; // data/input.txt
}

Тут важливо зафіксувати дві ідеї.

Перша: <filesystem> — це окремий заголовок. Якщо ви його не підключили, компілятор буде дивитися на вас як на людину, яка прийшла на іспит із математики з підручником із літератури.

Друга: fs — це просто коротке імʼя, щоб далі код виглядав зрозуміло. Ми не намагаємося «прискорити компіляцію» чи зробити якусь магію. Ми просто не хочемо читати std::filesystem:: у кожному рядку.

Створення fs::path

Тепер спокійно розберімося, як узагалі отримати обʼєкт типу fs::path. Важливо почати саме з цього, тому що новачки часто очікують від path якихось перевірок: «якщо шлях неправильний, напевно, конструктор посвариться». Не посвариться. path — це значення, як std::string: воно може зберігати що завгодно, і це «що завгодно» ще не мусить існувати на диску.

Найпростіший спосіб — рядковий літерал:

#include <filesystem>
#include <iostream>

int main() {
    namespace fs = std::filesystem;

    fs::path p{"logs/app.log"};
    std::cout << p.string() << '\n'; // logs/app.log
}

Другий поширений варіант — коли ви читаєте шлях як рядок, наприклад через std::getline, і хочете перетворити його на path:

#include <filesystem>
#include <iostream>
#include <string>

int main() {
    namespace fs = std::filesystem;

    std::string s = "data/notes.txt";
    fs::path p{s};

    std::cout << p.string() << '\n'; // data/notes.txt
}

І тут корисно запамʼятати просте правило: створення fs::path не означає, що файл існує. Це лише зручний контейнер для шляху з методами для роботи з компонентами. Перевірка існування та типу обʼєкта — це окремі функції (у цю лекцію ми їх не додаємо).

Склеювання шляхів: operator/ і operator/=

Тепер починається найприємніше: ми перестаємо склеювати шляхи вручну. У реальному житті «склеїти шлях» — це не «скласти рядки», а «додати компонент до шляху». У fs::path для цього є дуже впізнаваний оператор /.

Якщо читати код, це виглядає майже як у математиці: ліворуч базовий каталог, праворуч — імʼя файлу або підкаталог.

#include <filesystem>
#include <iostream>

int main() {
    namespace fs = std::filesystem;

    fs::path dir{"data"};
    fs::path file{"notes.txt"};

    fs::path full = dir / file;
    std::cout << full.string() << '\n'; // data/notes.txt
}

Якщо ви хочете не створювати новий обʼєкт, а дописати компонент до наявного шляху, використовуйте /=:

#include <filesystem>
#include <iostream>

int main() {
    namespace fs = std::filesystem;

    fs::path p{"data"};
    p /= "backup";
    p /= "notes.bak";

    std::cout << p.string() << '\n'; // data/backup/notes.bak
}

Додаткова перевага тут у тому, що operator/ виражає намір. Коли ви пишете dir / file, будь-хто, хто читає код, одразу розуміє: «будуємо шлях». Коли ж ви пишете dir + "/" + file, читач бачить інше: «будуємо рядок і сподіваємося, що слеші не зʼїдуть».

Невелика схема, як це варто сприймати:

flowchart LR
    A["fs::path('data')"] -->|operator/| C["fs::path('data/notes.txt')"]
    B["fs::path('notes.txt')"] -->|operator/| C

І ще один важливий момент для заспокоєння: оператор / тут — не ділення. Це просто перевантаження оператора для зручності.

Розбір шляху на частини: parent_path(), filename(), stem(), extension()

Ми підійшли до тієї частини, де fs::path особливо помітно виграє у звичайних рядків. Шлях складається з кількох частин. І замість того щоб гадати, де там останній "/" і скільки крапок у назві, ми можемо запитати шлях напряму.

Давайте візьмемо шлях "logs/app.log" і подивімося, які частини він містить:

#include <filesystem>
#include <iostream>

int main() {
    namespace fs = std::filesystem;

    fs::path p{"logs/app.log"};

    std::cout << "батьківський каталог: " << p.parent_path().string() << '\n'; // батьківський каталог: logs
    std::cout << "імʼя файлу: "          << p.filename().string()    << '\n'; // імʼя файлу: app.log
    std::cout << "основа: "              << p.stem().string()        << '\n'; // основа: app
    std::cout << "розширення: "          << p.extension().string()   << '\n'; // розширення: .log
}

Тут варто добре запамʼятати значення, бо новачки часто плутають два поняття.

filename() — це останній компонент шляху, тобто «як називається файл» (або останній каталог, якщо шлях веде до каталогу). Зазвичай це «імʼя + розширення».

stem() — це «імʼя файлу без розширення».

extension() — це розширення, і зазвичай воно повертається разом із крапкою. Так, розширення ".log", а не "log" — це очікувана семантика стандартної бібліотеки.

І ще одна важлива інтуїція: шлях може мати «порожні частини». Наприклад, шлях може не мати розширення. Або не мати батьківського каталогу, якщо це просто "notes.txt". Порожній результат — це не помилка, а цілком нормальна ситуація.

Зміна розширення: replace_extension()

Тепер розвʼяжімо класичну прикладну задачу: «зробити резервну копію файлу». Наївний варіант: знайти останню крапку, обрізати рядок і дописати ".bak". Кращий варіант: попросити path замінити розширення.

Метод replace_extension() робить саме це: змінює розширення усередині обʼєкта шляху.

#include <filesystem>
#include <iostream>

int main() {
    namespace fs = std::filesystem;

    fs::path p{"report.txt"};
    p.replace_extension(".bak");

    std::cout << p.string() << '\n'; // report.bak
}

Зверніть увагу на звичку, яка дуже допомагає: розширення часто передають із крапкою (".bak"). Якщо ви передасте "bak" без крапки, результат виглядатиме дивно, хоча формально шлях це дозволить. У навчальному коді краще бути передбачуваними: розширення — з крапкою.

Є ще одна тонкість, через яку рядковий підхід особливо часто ламається: «приховані файли» у світі Unix (наприклад, ".gitignore"). У такого імені перша крапка — це не «розширення», а частина імені. Тому логіка «усе після першої крапки — розширення» неправильна.

Перетворюємо fs::path назад на рядок: string()

Поки ми працюємо зі шляхом як з обʼєктом, усе зручно. Але щойно нам потрібно показати шлях користувачеві або записати його в лог, нам потрібен текст. Тут важливо не починати «розбирати нутрощі» вручну, а скористатися нормальним перетворенням.

Найзрозуміліший варіант для навчального коду — p.string():

#include <filesystem>
#include <iostream>

int main() {
    namespace fs = std::filesystem;

    fs::path p{"data/notes.txt"};
    std::cout << "Шлях: " << p.string() << '\n'; // Шлях: data/notes.txt
}

Чому варто наголосити саме на цьому? Бо початківці інколи міркують так: «раз path зберігає щось подібне до рядка, я зараз сам зберу рядок із parent_path і filename». Це зайве, а іноді й небезпечно. path уже вміє повертати рядкове подання коректно.

У цій лекції ми свідомо не заглиблюємося в тонкощі різних форматів подання (generic/native, кодування та платформні нюанси). Наша мета простіша: навчитися впевнено користуватися path як значенням і отримувати рядок там, де його треба вивести.

3. Приклад: акуратне складання шляхів у NoteVault

Тепер зробімо те, що зазвичай особливо тішить студентів: додамо корисну «дорослу» звичку в реальний код. Уявімо, що в нас є консольний застосунок NoteVault (умовна назва), який зберігає нотатки в текстовому файлі. У попередніх лекціях про файли ви могли зберігати шлях як рядок і відкривати std::ofstream("data/notes.txt"). Сьогодні ми подамо цей шлях як повноцінний fs::path, а також навчимося будувати шлях до резервної копії.

Спочатку заведемо невелику функцію, яка будує шлях до основного файлу нотаток. Вона поки нічого не створює і не перевіряє. Вона просто обчислює шлях. Це важливо: жодних дій із файловою системою.

#include <filesystem>
#include <string>

namespace fs = std::filesystem;

fs::path makeNotesPath(const std::string& userName) {
    fs::path base{"data"};
    fs::path file{userName + ".txt"};
    return base / file;
}

Тепер додамо функцію для шляху резервної копії. Тут нам якраз знадобиться replace_extension().

#include <filesystem>
#include <string>

namespace fs = std::filesystem;

fs::path makeBackupPath(const std::string& userName) {
    fs::path p = makeNotesPath(userName);
    p.replace_extension(".bak");
    return p;
}

А тепер подивімося на це в main — просто вивівши значення в консоль, без відкриття файлів.

#include <filesystem>
#include <iostream>
#include <string>

namespace fs = std::filesystem;

int main() {
    std::string userName;
    std::getline(std::cin, userName);

    fs::path notes = makeNotesPath(userName);
    fs::path bak   = makeBackupPath(userName);

    std::cout << notes.string() << '\n'; // наприклад: data/alice.txt
    std::cout << bak.string()   << '\n'; // наприклад: data/alice.bak
}

Зверніть увагу, як змінюється якість коду. Ми більше не залежимо від того, як саме ставити слеші. Ми явно виражаємо намір: «база + імʼя файлу», «замінити розширення». Такий код простіше читати, легше перевіряти візуально і важче випадково зламати.

Якщо хочеться трохи більше «діагностики» (а програмісти люблять її майже так само, як каву), можна вивести ще й частини шляху:

#include <filesystem>
#include <iostream>

namespace fs = std::filesystem;

void printPathParts(const fs::path& p) {
    std::cout << "повний: "  << p.string() << '\n';
    std::cout << "каталог: " << p.parent_path().string() << '\n';
    std::cout << "назва: "   << p.filename().string() << '\n';
}

Ця функція — чудовий приклад того, чому fs::path зручний: ви не ріжете рядок вручну, а запитуєте в шляху його структуру.

4. Типові помилки під час роботи з std::filesystem::path

Помилка № 1: склеювати шляхи рядками (base + "/" + name).
Такий код майже завжди виглядає «тимчасово нормальним», а потім раптом починає давати подвійні роздільники, пропущені роздільники або дивні випадки з порожніми компонентами. Найнеприємніше те, що помилки проявляються не завжди, а лише на деяких вхідних даних. Звичка використовувати fs::path і operator/ розвʼязує проблему вже на рівні дизайну: ви додаєте компоненти шляху, а не «вгадуєте, де слеш».

Помилка № 2: плутати filename() і stem().
Для новачків це класична плутанина: «я хотів отримати імʼя без розширення, узяв filename() і чомусь отримав "app.log"». Це не баг, а правильна поведінка. filename() — останній компонент повністю, а stem() — імʼя без розширення. Якщо регулярно виводити всі чотири частини (parent_path, filename, stem, extension) у налагоджувальному виводі, плутанина зникає за один вечір.

Помилка № 3: вважати, що fs::path перевіряє існування файлу.
fs::path — це просто обʼєкт-значення, як std::string. Він може зберігати шлях до неіснуючого файлу, до файлу без прав доступу — та й узагалі до чого завгодно. Це нормально. Помилка — покладати на path очікування «раз обʼєкт створився, значить, файл є». У результаті код «неочікувано» падає пізніше, уже під час реальної операції. Правильна модель така: path описує, куди ми хочемо звернутися, але не гарантує, що там справді щось є.

Помилка № 4: вручну змінювати розширення через find('.') і ламатися на ".gitignore" та файлах із кількома крапками.
Ручна логіка «знайти крапку і все після неї замінити» особливо болісна на назвах на кшталт "archive.tar.gz" і на прихованих файлах, які починаються з крапки. Краще довіряти extension(), stem() і replace_extension(), ніж писати власний мініпарсер імен файлів нашвидкуруч.