ランダムアクセス | Programming Place Plus　新C++編

#include <fstream>
#include <iostream>

static void tellp_test(const std::string& path, std::ios_base::openmode openmode)
{
    std::ofstream ofs(path, openmode);
    std::cout << ofs.tellp() << "\n";

    char s[] {"xyz"};
    ofs.write(s, sizeof(s));
    std::cout << ofs.tellp() << "\n";

    ofs.close();
}

static void tellg_test(const std::string& path, std::ios_base::openmode openmode)
{
    std::ifstream ifs(path, openmode);
    std::cout << ifs.tellg() << "\n";

    char s[4] {};
    ifs.read(s, sizeof(s));
    std::cout << ifs.tellg() << "\n";

    ifs.close();
}

int main()
{
    constexpr auto path = "test.bin";

    tellp_test(path, std::ios_base::out | std::ios_base::binary);
    tellg_test(path, std::ios_base::in | std::ios_base::binary);

    tellp_test(path, std::ios_base::out | std::ios_base::binary | std::ios_base::ate);
    tellg_test(path, std::ios_base::in | std::ios_base::binary | std::ios_base::ate);
}

ifs.seekg(距離, 基準);
ifs.seekg(位置);

ofs.seekp(距離, 基準);
ofs.seekp(位置);

ifs.seekg(30, std::ios_base::beg);  // 先頭から 30バイトのところへ移動
ofs.seekp(-10, std::ios_base::cur); // 10バイトだけ先頭に向かって移動

ifs.seekg(100);    // 決め打ちされた 100 は適切な位置ではないかもしれない

#include <cstdint>
#include <fstream>
#include <iostream>

int main()
{
    std::ifstream ifs("test.bin", std::ios_base::in | std::ios_base::binary);

    // データを読み込む。途中の 8バイトを飛ばす
    std::int32_t a {};
    char c[4] {};
    ifs.read(reinterpret_cast<char*>(&a), sizeof(a));
    ifs.seekg(8, std::ios_base::cur);  // 8バイト分だけ読み飛ばす
    ifs.read(c, sizeof(c));

    std::cout << std::hex << a << "\n"
              << std::dec << c << "\n";
}

#include <fstream>
#include <iostream>

int main()
{
    std::ofstream ofs("test.bin", std::ios_base::out | std::ios_base::binary | std::ios_base::app);

    char a[] {"aaa"};
    ofs.write(a, sizeof(a));

    char b[] {"bbb"};
    ofs.seekp(0);             // 先頭に戻しても・・
    ofs.write(b, sizeof(b));  // 末尾に書き込まれる
}

#include <fstream>
#include <iostream>
#include <vector>

int main()
{
    // バイナリ形式で読み書き両用オープン
    constexpr auto path = "test.bin";
    std::fstream fs(path, std::ios_base::in | std::ios_base::out | std::ios_base::binary);
    if (fs.fail()) {
        std::cerr << "File open error: " << path << "\n";
        return EXIT_FAILURE;
    }

    // 読み込み
    std::istreambuf_iterator<char> it_fs_begin(fs);
    std::istreambuf_iterator<char> it_fs_end {};
    std::vector<char> input_data(it_fs_begin, it_fs_end);
    if (fs.fail()) {
        std::cerr << "File read error: " << path << "\n";
        std::quick_exit(0);
    }

    // ファイルの先頭４バイトを上書きする
    char a[] {"aaa"};
    fs.seekp(0);
    fs.write(a, sizeof(a));

    fs.close();
    if (fs.fail()) {
        std::cerr << "File close error: " << path << "\n";
        std::quick_exit(0);
    }
}

// main.cpp
#include <cassert>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
#include <vector>
#include <sys/stat.h>
#include "analysis_cmdline_args.h"

using namespace std;

namespace beditor {

    constexpr auto app_name = "binary_editor";
    constexpr auto version_str = "1.0.3";

    // オプション
    using option_t = unsigned int;
    constexpr option_t option_none {0};          // オプションなし
    constexpr option_t option_lower_case {0b1};  // 小文字で表示する
    static option_t option {option_none};

    // 読み込むサイズ
    static uintmax_t read_size {numeric_limits<uintmax_t>::max()};

    // 出力開始位置
    static uintmax_t begin_pos {0};

    static bool get_file_size(const string& path, uintmax_t* file_size);
    static vector<char> read_file(ifstream& ifs, uintmax_t begin_pos, uintmax_t raed_size);
    static void print_help();
    static void print_version();
    static void on_option_help(const string& param);
    static void on_option_version(const string& param);
    static void on_option_lower(const string& param);
    static void on_option_size(const string& param);
    static void on_option_begin(const string& param);

    // オプション一覧
    static const vector<cmd_args::OptionInfo> options {
        { "-l", "--lower", on_option_lower, false },
        {"-s", "--size", on_option_size, true},
        {"-b", "--begin", on_option_begin, true},
    };

    // 大文字・小文字
    enum class Letter {
        upper,
        lower,
    };


    // バイト列を標準出力へ出力する
    //
    // address: 対象のバイト列を指し示すポインタ
    // size: 対象のバイト列のバイト数
    // letter: 16進数のアルファベットの表示方法
    static void print_byte_string(const void* address, size_t size, Letter letter);
}

int main(int argc, char** argv)
{
    // コマンドライン引数を vector に詰め替える
    auto cmdline_args = cmd_args::argv_to_vector(argc, argv);
    
    // ヘルプとバージョン情報のオプションを登録
    cmd_args::regist_help({"-h", "--help", beditor::on_option_help});
    cmd_args::regist_version({"-v", "--version", beditor::on_option_version});

    // コマンドライン引数の解析
    switch (cmd_args::analysis_cmdline_args(cmdline_args, 2, beditor::options)) {
    case cmd_args::AnalysisCmdlineArgsResult::correct:
        break;

    case cmd_args::AnalysisCmdlineArgsResult::correct_exit:
        quick_exit(EXIT_SUCCESS);
        break;

    case cmd_args::AnalysisCmdlineArgsResult::error_args_not_enough:
        cerr << "コマンドライン引数の指定が正しくありません。\n";
        beditor::print_help();
        quick_exit(EXIT_FAILURE);
        break;

    case cmd_args::AnalysisCmdlineArgsResult::error_invalid_option:
        cerr << "不正なオプションが指定されています。\n";
        beditor::print_help();
        quick_exit(EXIT_FAILURE);
        break;

    case cmd_args::AnalysisCmdlineArgsResult::error_invalid_parameter:
        cerr << "オプションのパラメータに不備があります。\n";
        beditor::print_help();
        quick_exit(EXIT_FAILURE);
        break;

    default:
        break;
    }

    // ファイルサイズを取得
    string path {cmdline_args.at(1)};
    uintmax_t file_size {};
    if (beditor::get_file_size(path, &file_size) == false) {
        cerr << path << "のサイズ取得に失敗しました。\n";
        quick_exit(EXIT_FAILURE);
    }

    // ファイルサイズを越えないように調整する
    if (beditor::begin_pos > file_size) {
        beditor::begin_pos = file_size;
    }
    if (beditor::begin_pos + beditor::read_size > file_size) {
        beditor::read_size = file_size - beditor::begin_pos;
    }

    // 対象のファイルをオープン
    ifstream ifs(path, ios_base::in | ios_base::binary);
    if (!ifs) {
        cerr << path << "が開けません。\n";
        quick_exit(EXIT_FAILURE);
    }

    // ファイルの内容を読み込む
    vector<char> bytes {beditor::read_file(ifs, beditor::begin_pos, beditor::read_size)};

    // バイト列を出力
    beditor::print_byte_string(
        bytes.data(),
        bytes.size(),
        (beditor::option & beditor::option_lower_case) ? beditor::Letter::lower : beditor::Letter::upper
    );
}

namespace beditor {

    // ファイルサイズを返す
    static bool get_file_size(const string& path, uintmax_t* file_size)
    {
        assert(file_size);

        // ファイルの情報を取得
        struct stat st {};
        if (stat(path.c_str(), &st) != 0) {
            return false;
        }

        // ファイルかどうか
        // S_ISREG(st.st_mode); の方がシンプルだが、Visual Studio では使えない。
        if ((st.st_mode & S_IFMT) != S_IFREG) {
            return false;
        }

        *file_size = st.st_size;
        return true;
    }

    // ファイルから必要なサイズ分だけ読み込む
    static vector<char> read_file(ifstream& ifs, uintmax_t begin_pos, uintmax_t raed_size)
    {
        if (begin_pos == 0 && raed_size == numeric_limits<uintmax_t>::max()) {
            // ファイルの中身をすべて読み込む
            istreambuf_iterator<char> it_ifs_begin(ifs);
            istreambuf_iterator<char> it_ifs_end {};
            vector<char> bytes(it_ifs_begin, it_ifs_end);
            return bytes;
        }
        else {
            // ファイルの中身を必要なサイズ分だけ読み込む。
            vector<char> bytes(static_cast<vector<char>::size_type>(raed_size));
            ifs.seekg(begin_pos, ios_base::beg);
            ifs.read(bytes.data(), raed_size);
            return bytes;
        }
    }

    // ヘルプメッセージを出力
    static void print_help()
    {
        cout << "使い方:\n"
             << "> " << app_name << " 対象のファイルパス\n"
             << "> " << app_name << " 対象のファイルパス オプション\n"
             << "> " << app_name << " -h（または --help)\n"
             << "> " << app_name << " -v（または --version）\n"
             << "\n"
             << "-h（--help）    使い方を表示します。\n"
             << "-v（--version） バージョン情報を表示します。\n"
             << "\n"
             << "オプション:\n"
             << "-l (--lower)      --> 16進数のアルファベット部分を小文字で表示します。\n"
             << "-s (--size) 整数  --> 指定サイズまでで表示を終了します。"
             << "-b (--begin) 整数 --> 指定位置から表示を開始します。"
             << endl;
    }

    // バージョン情報を出力
    static void print_version()
    {
        cout << app_name << " version: " << version_str << endl;
    }

    // ヘルプオプションを発見したときに呼び出される関数
    static void on_option_help(const std::string& param)
    {
        (void)param;
        print_help();
    }

    // バージョン情報オプションを発見したときに呼び出される関数
    static void on_option_version(const std::string& param)
    {
        (void)param;
        print_version();
    }

    // 小文字化オプションを発見したときに呼び出される関数
    static void on_option_lower(const std::string& param)
    {
        (void)param;
        option |= option_lower_case;
    }

    // サイズ指定オプションを発見したときに呼び出される関数
    static void on_option_size(const string& param)
    {
        istringstream iss {param};
        uintmax_t size {};
        iss >> size;
        if (iss) {
            read_size = size;
        }
        else {
            cerr << "サイズの指定が不適切です。\n";
            quick_exit(EXIT_FAILURE);
        }
    }

    // 出力開始位置の指定オプションを発見したときに呼び出される関数
    static void on_option_begin(const string& param)
    {
        istringstream iss {param};
        uintmax_t begin {};
        iss >> begin;
        if (iss) {
            begin_pos = begin;
        }
        else {
            cerr << "出力開始位置の指定が不適切です。\n";
            quick_exit(EXIT_FAILURE);
        }
    }

    // バイト列を標準出力へ出力する
    static void print_byte_string(const void* address, size_t size, Letter letter)
    {
        auto p = static_cast<const unsigned char*>(address);
        auto remain_byte = size;

        while (remain_byte > 0) {
            size_t byte_num {remain_byte >= 16 ? 16 : remain_byte};

            for (size_t i {0}; i < byte_num; ++i) {
                cout << setw(2) << setfill('0') << hex
                     << (letter == Letter::upper ? uppercase : nouppercase)
                     << static_cast<unsigned int>(*p) << " ";
                ++p;
            }
            cout << "\n";

            remain_byte -= byte_num;
        }
    }
}

// analysis_cmdline_args.cpp
#include "analysis_cmdline_args.h"
#include <algorithm>
#include <cassert>
#include <iterator>

using namespace std;

namespace cmd_args {

    static OptionInfo help_info {};
    static OptionInfo version_info {};


    // コマンドライン引数を std::vector<std::string> に格納して返す
    vector<string> argv_to_vector(int argc, char** argv)
    {
        vector<string> vec {};
        for (int i {0}; i < argc; ++i) {
            vec.push_back(argv[i]);
        }
        return vec;
    }

    // ヘルプオプションを登録する
    void regist_help(const OptionInfo& info)
    {
        assert(info.short_name != "" || info.long_name != "");
        assert(info.callback_func);

        help_info = info;
    }

    // バージョン情報オプションを登録する
    void regist_version(const OptionInfo& info)
    {
        assert(info.short_name != "" || info.long_name != "");
        assert(info.callback_func);

        version_info = info;
    }

    // コマンドライン引数を解析する
    AnalysisCmdlineArgsResult analysis_cmdline_args(const vector<string>& cmdline_args, std::size_t option_start_index, const vector<OptionInfo>& options)
    {
        // コマンドライン引数の個数チェック
        if (cmdline_args.size() < 2) {
            return AnalysisCmdlineArgsResult::error_args_not_enough;
        }

        // ヘルプ
        if (cmdline_args.at(1) == help_info.short_name || cmdline_args.at(1) == help_info.long_name) {
            help_info.callback_func("");
            return AnalysisCmdlineArgsResult::correct_exit;
        }

        // バージョン情報
        if (cmdline_args.at(1) == version_info.short_name || cmdline_args.at(1) == version_info.long_name) {
            version_info.callback_func("");
            return AnalysisCmdlineArgsResult::correct_exit;
        }

        // オプションを探す
        for (size_t i {option_start_index}; i < cmdline_args.size(); ++i) {
            auto it_opt = find_if(
                cbegin(options),
                cend(options),
                [arg = cmdline_args.at(i)](const OptionInfo& opt) {
                    return arg == opt.short_name || arg == opt.long_name;
                }
            );

            if (it_opt == cend(options)) {
                // 該当するオプションがない
                return AnalysisCmdlineArgsResult::error_invalid_option;
            }
            else {
                // 発見したオプションに応じた登録関数をコールバック
                if (it_opt->has_param) {
                    ++i;
                    if (i < cmdline_args.size()) {
                        it_opt->callback_func(cmdline_args.at(i));
                    }
                    else {
                        return AnalysisCmdlineArgsResult::error_invalid_parameter;
                    }
                }
                else {
                    it_opt->callback_func("");
                }
            }
        }

        return AnalysisCmdlineArgsResult::correct;
    }
}

// analysis_cmdline_args.h
#ifndef ANALYSIS_CMDLINE_ARGS_INCLUDED
#define ANALYSIS_CMDLINE_ARGS_INCLUDED

#include <functional>
#include <string>
#include <vector>

namespace cmd_args {

    // コマンドライン解析の結果
    enum class AnalysisCmdlineArgsResult {
        correct,                    // 正しい指定
        correct_exit,               // 正しい指定だが、プログラムは終了させる
        error_args_not_enough,      // エラー。コマンドライン引数が不足
        error_invalid_option,       // エラー。不正なオプションを発見
        error_invalid_parameter,    // エラー。パラメータの指定が正しくない
    };

    // オプション発見時のコールバック関数型
    using option_callback_t = std::function<void(const std::string&)>;

    // オプション情報
    struct OptionInfo {
        std::string                 short_name;     // 短い名前（不要なら空文字列）
        std::string                 long_name;      // 長い名前（不要なら空文字列）
        option_callback_t           callback_func;  // オプション発見時にコールバックする関数
        bool                        has_param;      // パラメータの有無
    };



    // コマンドライン引数を std::vector<std::string> に格納して返す
    std::vector<std::string> argv_to_vector(int argc, char** argv);

    // ヘルプオプションを登録する
    void regist_help(const OptionInfo& info);

    // バージョン情報オプションを登録する
    void regist_version(const OptionInfo& info);

    // コマンドライン引数を解析する
    AnalysisCmdlineArgsResult analysis_cmdline_args(const std::vector<std::string>& cmdline_args, std::size_t option_start_index, const std::vector<OptionInfo>& options);

}

#endif