【C++】Boost.Filesystemでファイルサイズを確実に取得する方法

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    boost::filesystem::path dir("/home/user");
    boost::filesystem::path filename("documents/../example.txt");
    boost::filesystem::path fullPath = dir / filename;
    // 正規化してパスを取得
    boost::filesystem::path normalizedPath = fullPath.lexically_normal();
    std::cout << "結合して正規化したパス: " << normalizedPath.string()
              << std::endl;
    return 0;
}

結合して正規化したパス: \home\user\example.txt

#include <fcntl.h>
#include <io.h>
#include <boost/filesystem.hpp>
#include <iostream>
#include <locale>

int main() {
    // コンソールをワイド文字出力モードに切り替え
    _setmode(_fileno(stdout), _O_U16TEXT);

    // ワイド文字列リテラルでパスを構築
    boost::filesystem::path p(L"例のファイル.txt");
    // native() は wchar_t ベースの文字列を返す
    std::wcout << L"パス(ワイド文字): " << p.native() << L"\n";
    return 0;
}

パス(ワイド文字): 例のファイル.txt

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    // . はカレントディレクトリを指す
    boost::filesystem::path targetPath(".");
    boost::system::error_code ec;
    // パスの状態を取得
    auto status = boost::filesystem::status(targetPath, ec);
    if (ec) {
        std::cerr << "エラー: " << ec.message() << std::endl;
        return 1;
    }
    if (boost::filesystem::exists(status)) {
        if (boost::filesystem::is_regular_file(status)) {
            std::cout << "これは通常のファイルです。" << std::endl;
        } else if (boost::filesystem::is_directory(status)) {
            std::cout << "これはディレクトリです。" << std::endl;
        } else if (boost::filesystem::is_symlink(status)) {
            std::cout << "これはシンボリックリンクです。" << std::endl;
        } else {
            std::cout << "その他の種類のエントリです。" << std::endl;
        }
    } else {
        std::cout << "指定したパスは存在しません。" << std::endl;
    }
    return 0;
}

これはディレクトリです。

#include <boost/filesystem.hpp>
boost::uintmax_t file_size(const boost::filesystem::path& p);

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    boost::filesystem::path filePath("example.txt");
    try {
        boost::uintmax_t size = boost::filesystem::file_size(filePath);
        std::cout << "ファイルサイズ: " << size << " バイト" << std::endl;
    } catch (const boost::filesystem::filesystem_error& e) {
        std::cerr << "エラー: " << e.what() << std::endl;
    }
    return 0;
}

ファイルサイズ: 436 バイト

#include <boost/version.hpp>
#include <iostream>
int main() {
    std::cout << "Boostバージョン: "
              << BOOST_VERSION / 100000 << "."
              << BOOST_VERSION / 100 % 1000 << "."
              << BOOST_VERSION % 100000 / 1000 << std::endl;
    return 0;
}

Boostバージョン: 1.85.8

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    boost::filesystem::path targetPath("sample.txt");
    if (boost::filesystem::exists(targetPath)) {
        std::cout << "ファイルは存在します。" << std::endl;
    } else {
        std::cout << "ファイルは存在しません。" << std::endl;
    }
    return 0;
}

ファイルは存在しません。

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    boost::filesystem::path targetPath("sample.txt");
    boost::system::error_code ec;
    auto fileStatus = boost::filesystem::status(targetPath, ec);
    if (ec) {
        std::cerr << "エラー: " << ec.message() << std::endl;
        return 1;
    }
    auto perms = fileStatus.permissions();
    if ((perms & boost::filesystem::owner_read) != 0) {
        std::cout << "所有者に読み取り権限があります。" << std::endl;
    } else {
        std::cout << "所有者に読み取り権限がありません。" << std::endl;
    }
    if ((perms & boost::filesystem::owner_write) != 0) {
        std::cout << "所有者に書き込み権限があります。" << std::endl;
    } else {
        std::cout << "所有者に書き込み権限がありません。" << std::endl;
    }
    if ((perms & boost::filesystem::owner_exe) != 0) {
        std::cout << "所有者に実行権限があります。" << std::endl;
    } else {
        std::cout << "所有者に実行権限がありません。" << std::endl;
    }
    return 0;
}

所有者に読み取り権限があります。
所有者に書き込み権限があります。
所有者に実行権限がありません。

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    boost::filesystem::path targetPath("sample.txt");
    boost::system::error_code ec;
    if (boost::filesystem::exists(targetPath, ec)) {
        std::cout << "ファイルは存在します。" << std::endl;
    } else {
        if (ec) {
            std::cerr << "エラー: " << ec.message() << std::endl;
        } else {
            std::cout << "ファイルは存在しません。" << std::endl;
        }
    }
    return 0;
}

ファイルは存在します。

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    try {
        boost::filesystem::path invalidPath("nonexistent.txt");
        auto size = boost::filesystem::file_size(invalidPath);
    } catch (const boost::filesystem::filesystem_error& e) {
        std::cerr << "例外発生: " << e.what() << std::endl;
        std::cerr << "エラーコード: " << e.code().message() << std::endl;
    }
    return 0;
}

例外発生: boost::filesystem::file_size: 指定されたファイルが見つかりません。 [system:2]: "nonexistent.txt"
エラーコード: 指定されたファイルが見つかりません。

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    try {
        boost::filesystem::path targetPath("sample.txt");
        auto size = boost::filesystem::file_size(targetPath);
        std::cout << "ファイルサイズ: " << size << " バイト" << std::endl;
    } catch (const boost::filesystem::filesystem_error& e) {
        std::cerr << "ファイル操作中にエラーが発生しました。" << std::endl;
        std::cerr << "エラー内容: " << e.what() << std::endl;
        std::cerr << "エラーコード: " << e.code().message() << std::endl;
        // 必要に応じて追加のエラー処理を行う
    }
    return 0;
}

ファイル操作中にエラーが発生しました。
エラー内容: boost::filesystem::file_size: 指定されたファイルが見つかりません。 [system:2]: "sample.txt"
エラーコード: 指定されたファイルが見つかりません。

#include <boost/filesystem.hpp>
#include <iostream>
void handleFilesystemError(const boost::filesystem::filesystem_error& e) {
    if (e.code() == boost::system::errc::no_such_file_or_directory) {
        std::cerr << "エラー: ファイルが見つかりません。" << std::endl;
        // ファイルが存在しない場合の処理
    } else if (e.code() == boost::system::errc::permission_denied) {
        std::cerr << "エラー: アクセス権限がありません。" << std::endl;
        // 権限不足の場合の処理
    } else {
        std::cerr << "その他のエラー: " << e.what() << std::endl;
    }
}
int main() {
    try {
        boost::filesystem::path targetPath("restricted.txt");
        auto size = boost::filesystem::file_size(targetPath);
        std::cout << "ファイルサイズ: " << size << " バイト" << std::endl;
    } catch (const boost::filesystem::filesystem_error& e) {
        handleFilesystemError(e);
    }
    return 0;
}

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    boost::filesystem::path linkPath("shortcut.lnk");
    boost::system::error_code ec;
    if (boost::filesystem::is_symlink(linkPath, ec)) {
        std::cout << linkPath << "はシンボリックリンクです。" << std::endl;
        // リンク先のパスを取得
        boost::filesystem::path targetPath = boost::filesystem::read_symlink(linkPath, ec);
        if (!ec) {
            std::cout << "リンク先: " << targetPath.string() << std::endl;
        } else {
            std::cerr << "リンク先の取得に失敗: " << ec.message() << std::endl;
        }
    } else {
        if (ec) {
            std::cerr << "エラー: " << ec.message() << std::endl;
        } else {
            std::cout << linkPath << "はシンボリックリンクではありません。" << std::endl;
        }
    }
    return 0;
}

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    boost::filesystem::path filePath("example.txt");
    boost::system::error_code ec;
    auto status = boost::filesystem::status(filePath, ec);
    if (ec) {
        std::cerr << "エラー: " << ec.message() << std::endl;
        return 1;
    }
    // inode番号やリンク数を取得してハードリンクの数を推測
    auto hardLinkCount = boost::filesystem::hard_link_count(filePath, ec);
    if (ec) {
        std::cerr << "リンク数の取得に失敗: " << ec.message() << std::endl;
    } else {
        std::cout << "ハードリンクの数: " << hardLinkCount << std::endl;
    }
    return 0;
}

#include <boost/filesystem.hpp>
#include <boost/system/error_code.hpp>
#include <iostream>
#include <limits>
#include <vector>

int main() {
    // 調査対象のファイルリスト
    std::vector<boost::filesystem::path> files = {"file1.bin", "file2.bin",
                                                  "file3.bin"};

    boost::uintmax_t totalSize = 0;

    for (const auto& file : files) {
        boost::system::error_code ec;
        // ファイルサイズを取得（エラーコード受け取り版）
        auto size = boost::filesystem::file_size(file, ec);
        if (ec) {
            std::cerr << "ファイル " << file
                      << " のサイズ取得に失敗: " << ec.message() << std::endl;
            continue;
        }

        // オーバーフローをチェック
        if (totalSize > std::numeric_limits<boost::uintmax_t>::max() - size) {
            std::cerr << "合計サイズが最大値を超えます。計算を中断します。"
                      << std::endl;
            break;
        }

        totalSize += size;
    }

    std::cout << "合計ファイルサイズ: " << totalSize << " バイト" << std::endl;
    return 0;
}

合計ファイルサイズ: 38315 バイト

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    // .はカレントディレクトリを指す
    boost::filesystem::path dirPath(".");
    boost::system::error_code ec;
    for (auto it = boost::filesystem::directory_iterator(dirPath, ec);
         it != boost::filesystem::directory_iterator(); ++it) {
        if (ec) {
            std::cerr << "エラー: " << ec.message() << std::endl;
            break;
        }
        std::cout << "エントリ: " << it->path().string() << std::endl;
    }
    return 0;
}

エントリ: .\example.txt
エントリ: .\log.txt
エントリ: .\main.cpp
エントリ: .\main.exe
エントリ: .\output.bin
エントリ: .\pch.h
エントリ: .\text.txt

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    // . はカレントディレクトリを指す
    boost::filesystem::path dirPath(".");
    boost::system::error_code ec;
    for (auto it = boost::filesystem::recursive_directory_iterator(dirPath, ec);
         it != boost::filesystem::recursive_directory_iterator(); ++it) {
        if (ec) {
            std::cerr << "エラー: " << ec.message() << std::endl;
            break;
        }
        std::cout << "エントリ: " << it->path().string() << std::endl;
    }
    return 0;
}

エントリ: .\.vscode
エントリ: .\.vscode\c_cpp_properties.json
エントリ: .\.vscode\launch.json
エントリ: .\.vscode\settings.json
エントリ: .\.vscode\tasks.json
エントリ: .\example.txt
エントリ: .\log.txt
エントリ: .\main.cpp
エントリ: .\main.exe
エントリ: .\output.bin
エントリ: .\pch.h
エントリ: .\text.txt

#include <boost/filesystem.hpp>
#include <iostream>

int main() {
    namespace fs = boost::filesystem;
    fs::path dirPath("sample_directory");
    boost::system::error_code ec;

    // イテレータを例外ではなく error_code で初期化
    fs::recursive_directory_iterator it(dirPath, ec), end;
    if (ec) {
        std::cerr << "初期化エラー: " << ec.message() << std::endl;
        return 1;
    }

    const std::size_t maxDepth = 2;
    for (; it != end; /* ++it は下で行います */) {
        // 次の要素へ進む（エラー抑制版）
        it.increment(ec);
        if (ec) {
            std::cerr << "イテレーション中のエラー: " << ec.message() << std::endl;
            ec.clear();
            continue;
        }

        // 深さが maxDepth を超えたら、このディレクトリ以下をスキップ
        if (it.depth() > maxDepth) {
            it.pop();  // このサブディレクトリから抜ける
            continue;
        }

        std::cout << "エントリ: " << it->path().string() << std::endl;
    }

    return 0;
}

#include <boost/filesystem.hpp>
#include <iostream>

namespace fs = boost::filesystem;

int main() {
    // 初期化エラーを受け取るための error_code
    boost::system::error_code ec;

    // ディレクトリのシンボリックリンクを再帰的にたどるオプションを指定してイテレータを構築
    fs::recursive_directory_iterator it(
        "sample_directory", fs::directory_options::follow_directory_symlink,
        ec);
    if (ec) {
        std::cerr << "初期化エラー: " << ec.message() << std::endl;
        return 1;
    }

    fs::recursive_directory_iterator end;
    for (; it != end; ++it) {
        std::cout << "エントリ: " << it->path().string() << std::endl;
    }

    return 0;
}

#include <boost/filesystem.hpp>
#include <future>
#include <vector>
#include <iostream>
boost::uintmax_t getFileSize(const boost::filesystem::path& p) {
    boost::system::error_code ec;
    auto size = boost::filesystem::file_size(p, ec);
    if (ec) {
        std::cerr << "エラー: " << ec.message() << std::endl;
        return 0;
    }
    return size;
}
int main() {
    std::vector<boost::filesystem::path> files = {"file1.bin", "file2.bin", "file3.bin"};
    std::vector<std::future<boost::uintmax_t>> futures;
    for (const auto& file : files) {
        futures.emplace_back(std::async(std::launch::async, getFileSize, file));
    }
    boost::uintmax_t totalSize = 0;
    for (auto& fut : futures) {
        totalSize += fut.get();
    }
    std::cout << "合計サイズ: " << totalSize << " バイト" << std::endl;
    return 0;
}

合計サイズ: 928406 バイト

\\サーバ名\共有名\パス

\\server01\shared\folder\file.txt

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    boost::filesystem::path uncPath(R"(\\server01\shared\folder\file.txt)");
    if (boost::filesystem::exists(uncPath)) {
        auto size = boost::filesystem::file_size(uncPath);
        std::cout << "ファイルサイズ: " << size << " バイト" << std::endl;
    } else {
        std::cerr << "ファイルが存在しません。" << std::endl;
    }
    return 0;
}

#include <boost/filesystem.hpp>
#include <iostream>
int main() {
    boost::filesystem::path filePath("example.txt");
    boost::system::error_code ec;
    auto perms = boost::filesystem::status(filePath, ec).permissions();
    if (ec) {
        std::cerr << "エラー: " << ec.message() << std::endl;
        return 1;
    }
    if ((perms & boost::filesystem::owner_read) != 0) {
        std::cout << "所有者に読み取り権限があります。" << std::endl;
    } else {
        std::cout << "所有者に読み取り権限がありません。" << std::endl;
    }
    // 権限の変更例(書き込み権限を追加)
    boost::filesystem::permissions(filePath, boost::filesystem::add_perms | boost::filesystem::owner_write, ec);
    if (ec) {
        std::cerr << "権限変更エラー: " << ec.message() << std::endl;
    } else {
        std::cout << "権限を変更しました。" << std::endl;
    }
    return 0;
}

所有者に読み取り権限があります。
権限を変更しました。

#include <filesystem>
#include <iostream>
int main() {
    std::filesystem::path filePath("example.txt");
    try {
        auto size = std::filesystem::file_size(filePath);
        std::cout << "ファイルサイズ: " << size << " バイト" << std::endl;
    } catch (const std::filesystem::filesystem_error& e) {
        std::cerr << "エラー: " << e.what() << std::endl;
    }
    return 0;
}

ファイルサイズ: 19 バイト

#include <boost/filesystem.hpp>
#include <iostream>
#include <fstream>
int main() {
    boost::filesystem::path logFile("application.log");
    static uintmax_t previousSize = 0;
    boost::system::error_code ec;
    if (!boost::filesystem::exists(logFile, ec)) {
        std::cerr << "ログファイルが存在しません。" << std::endl;
        return 1;
    }
    auto currentSize = boost::filesystem::file_size(logFile, ec);
    if (ec) {
        std::cerr << "サイズ取得エラー: " << ec.message() << std::endl;
        return 1;
    }
    uintmax_t diff = currentSize - previousSize;
    std::cout << "ログの増加量: " << diff << " バイト" << std::endl;
    // 差分をファイルに保存(次回の比較用)
    std::ofstream ofs("size_record.txt");
    ofs << currentSize;
    ofs.close();
    previousSize = currentSize;
    return 0;
}

ログの増加量: 82 バイト

#include <boost/cstdint.hpp> // boost::uintmax_t のため
#include <boost/filesystem.hpp>
#include <iostream>
#include <limits> // std::numeric_limits

int main() {
    // . からの相対パスでディレクトリを指定
    boost::filesystem::path dirPath(".");
    boost::uintmax_t totalSize = 0;
    boost::system::error_code ec;

    // ディレクトリ再帰走査
    for (auto it = boost::filesystem::recursive_directory_iterator(dirPath, ec);
         it != boost::filesystem::recursive_directory_iterator(); ++it) {
        if (ec) {
            std::cerr << "走査エラー: " << ec.message() << std::endl;
            break;
        }
        if (boost::filesystem::is_regular_file(it->status())) {
            auto size = boost::filesystem::file_size(it->path(), ec);
            if (ec) {
                std::cerr << "サイズ取得エラー: " << ec.message() << std::endl;
                continue;
            }
            // オーバーフロー防止
            if (totalSize >
                std::numeric_limits<boost::uintmax_t>::max() - size) {
                std::cerr << "容量超過の可能性があります。計算中断。"
                          << std::endl;
                break;
            }
            totalSize += size;
        }
    }

    std::cout << "対象ディレクトリの合計容量: " << totalSize << " バイト"
              << std::endl;

    // 例：空き容量と比較（型を boost::uintmax_t に統一）
    boost::uintmax_t freeSpace =
        10ULL * 1024 * 1024 * 1024; // 例：10GB の空き容量
    if (totalSize > freeSpace) {
        std::cerr << "容量不足です。バックアップを中止します。" << std::endl;
    } else {
        std::cout << "容量十分です。バックアップを進めてください。"
                  << std::endl;
    }

    return 0;
}

対象ディレクトリの合計容量: 103720760 バイト
容量十分です。バックアップを進めてください。

auto st = boost::filesystem::status(path);
if (boost::filesystem::exists(st)) {
    // 処理
}

boost::system::error_code ec;
auto st = boost::filesystem::status(path, ec);
if (!ec && boost::filesystem::exists(st)) {
    // 処理
}

#if BOOST_VERSION >= 106500
// Boost 1.65以降のAPI
#else
// それ以前のAPI
#endif