ファイルシステム | Programming Place Plus　新C++編

#include <cstdint>
#include <fstream>
#include <string>

// .bmpファイルに書き出す
//
// path: ファイルパス
// width: 横方向のピクセル数
// height: 縦方向のピクセル数
// pixels: ピクセル情報
// 戻り値: 成否
bool save_bmp(const std::string& path, unsigned int width, unsigned int height, const std::vector<std::vector<Color>>& pixels)
{
    std::ofstream ofs(path, std::ios_base::out | std::ios_base::binary);
    if (!ofs) {
        return false;
    }

    // ----- ファイルヘッダ部 -----
    // Windows API の BITMAPFILEHEADER構造体にあたる。
    // https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapfileheader

    // ファイルタイプ
    // 必ず 0x4d42 ("BM" のこと)
    constexpr std::uint16_t file_type {0x4d42};
    ofs.write(reinterpret_cast<const char*>(&file_type), sizeof(file_type));

    // ファイルサイズ
    // 縦横のピクセル数 * １ピクセル当たりのバイト数(PaintScript では 4バイト固定) + ヘッダ部のバイト数。
    // ヘッダ部の大きさは、sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) より。
    const std::uint32_t file_size {width * height * 4 + 54};
    ofs.write(reinterpret_cast<const char*>(&file_size), sizeof(file_size));

    // 予約領域
    const std::uint32_t reserved {0};
    ofs.write(reinterpret_cast<const char*>(&reserved), sizeof(reserved));

    // ファイル先頭から、ピクセル情報までの距離
    const std::uint32_t offset_to_pixels {54};
    ofs.write(reinterpret_cast<const char*>(&offset_to_pixels), sizeof(offset_to_pixels));


    // ----- ビットマップ情報ヘッダ部 -----
    // Windows API の _BITMAPINFOHEADER構造体にあたる。
    // https://learn.microsoft.com/ja-jp/windows/win32/wmdm/-bitmapinfoheader

    // ビットマップ情報ヘッダ部のサイズ
    const std::uint32_t bitmap_info_header_size {40};
    ofs.write(reinterpret_cast<const char*>(&bitmap_info_header_size), sizeof(bitmap_info_header_size));

    // 横方向のピクセル数
    const std::int32_t w {static_cast<std::int32_t>(width)};
    ofs.write(reinterpret_cast<const char*>(&w), sizeof(w));

    // 縦方向のピクセル数
    const std::int32_t h {static_cast<std::int32_t>(height)};
    ofs.write(reinterpret_cast<const char*>(&h), sizeof(h));

    // プレーン数。必ず 1
    const std::uint16_t planes {1};
    ofs.write(reinterpret_cast<const char*>(&planes), sizeof(planes));

    // １ピクセル当たりのビット数。PaintScript では 24 に固定
    const std::uint16_t bit_count {24};
    ofs.write(reinterpret_cast<const char*>(&bit_count), sizeof(bit_count));

    // 圧縮形式。無圧縮は 0
    const std::uint32_t compression {0};
    ofs.write(reinterpret_cast<const char*>(&compression), sizeof(compression));

    // 画像サイズ。無圧縮であれば 0 で構わない
    const std::uint32_t image_size {0};
    ofs.write(reinterpret_cast<const char*>(&image_size), sizeof(image_size));

    // メートル当たりの横方向のピクセル数の指示。不要なら 0 にできる
    const std::int32_t x_pixels_per_meter {0};
    ofs.write(reinterpret_cast<const char*>(&x_pixels_per_meter), sizeof(x_pixels_per_meter));

    // メートル当たりの縦方向のピクセル数の指示。不要なら 0 にできる
    const std::int32_t y_pixels_per_meter {0};
    ofs.write(reinterpret_cast<const char*>(&y_pixels_per_meter), sizeof(y_pixels_per_meter));

    // カラーテーブル内の色のうち、実際に使用している個数。パレット形式でなければ無関係
    const std::uint32_t clr_used {0};
    ofs.write(reinterpret_cast<const char*>(&clr_used), sizeof(clr_used));

    // カラーテーブル内の色のうち、重要色である色の個数。パレット形式でなければ無関係
    const std::uint32_t clr_important {0};
    ofs.write(reinterpret_cast<const char*>(&clr_important), sizeof(clr_important));


    // ----- ピクセル情報 -----
    // 各ピクセルは RGB の各8bit である想定。
    for (std::int32_t y {h - 1}; y >= 0; --y) {
        for (std::int32_t x {0}; x < w; ++x) {
            const Color pixel {pixels.at(y).at(x)};
            ofs.write(reinterpret_cast<const char*>(&pixel.blue), sizeof(pixel.blue));
            ofs.write(reinterpret_cast<const char*>(&pixel.green), sizeof(pixel.green));
            ofs.write(reinterpret_cast<const char*>(&pixel.red), sizeof(pixel.red));
        }
    }

    return true;
}

#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <vector>

struct Color {
    unsigned char red;          // 赤成分
    unsigned char green;        // 緑成分
    unsigned char blue;         // 青成分
};

// キャンバスの型
using canvas_t = std::vector<std::vector<Color>>;

// キャンバスの大きさを変更する
void resize_canvas(canvas_t& canvas, std::size_t width, std::size_t height)
{
    canvas.resize(height);
    for (auto& row : canvas) {
        row.resize(width);
    }
}

// キャンバス内の座標かどうか判定する
bool is_canvas_inside(const canvas_t& canvas, int x, int y)
{
    if (x < 0 || static_cast<int>(canvas[0].size()) <= x) {
        return false;
    }
    if (y < 0 || static_cast<int>(canvas.size()) <= y) {
        return false;
    }
    return true;
}

// キャンバスに点を描く
void paint_dot(canvas_t& canvas, int x, int y, Color color)
{
    if (!is_canvas_inside(canvas, x, y)) {
        return;
    }

    canvas.at(y).at(x) = color;
}

// キャンバスに四角形を描く
void paint_rect(canvas_t& canvas, int left, int top, int right, int bottom, Color color)
{
    for (int y {top}; y <= bottom; ++y) {
        for (int x {left}; x <= right; ++x) {
            paint_dot(canvas, x, y, color);
        }
    }
}

int main()
{
    std::size_t width {500};
    std::size_t height {500};
    canvas_t canvas {};
    resize_canvas(canvas, width, height);

    paint_rect(canvas, 100, 150, 400, 300, {0, 255, 0});

    if (!save_bmp("test.bmp", width, height, canvas)) {
        std::cerr << ".bmpファイルの保存に失敗しました。\n";
        std::quick_exit(0);
    }
}

#include <cassert>
#include <cstdint>
#include <fstream>

// .bmpファイルを読み込む
//
// path: ファイルパス
// width: 横方向のピクセル数を受け取るポインタ。ヌルポインタ不可
// height: 縦方向のピクセル数を受け取るポインタ。ヌルポインタ不可
// pixels: ピクセル情報を受け取るポインタ。ヌルポインタ不可
// 戻り値: 成否
bool load_bmp(const std::string& path, unsigned int* width, unsigned int* height, std::vector<std::vector<Color>>* pixels)
{
    assert(width);
    assert(height);
    assert(pixels);

    std::ifstream ifs(path, std::ios_base::in | std::ios_base::binary);
    if (!ifs) {
        return false;
    }

    // 不要なところを読み飛ばす
    ifs.seekg(18, std::ios_base::beg);

    // 横方向のピクセル数
    std::int32_t w {};
    ifs.read(reinterpret_cast<char*>(&w), sizeof(w));
    if (w < 1) {
        return false;
    }
    *width = static_cast<unsigned int>(w);
    
    // 縦方向のピクセル数
    std::int32_t h {};
    ifs.read(reinterpret_cast<char*>(&h), sizeof(h));
    if (h < 1) {
        return false;
    }
    *height = static_cast<unsigned int>(h);

    // 不要なところを読み飛ばす
    ifs.seekg(28, std::ios_base::cur);

    // ピクセル情報
    // vector は、ビットマップの大きさに合わせて resize する。
    pixels->resize(h);
    for (auto& row : *pixels) {
        row.resize(w);
    }
    for (std::int32_t y {h - 1}; y >= 0; --y) {
        for (std::int32_t x {0}; x < w; ++x) {
            std::uint8_t b {};
            ifs.read(reinterpret_cast<char*>(&b), sizeof(b));
            std::uint8_t g {};
            ifs.read(reinterpret_cast<char*>(&g), sizeof(g));
            std::uint8_t r {};
            ifs.read(reinterpret_cast<char*>(&r), sizeof(r));

            pixels->at(y).at(x) = Color{r, g, b};
        }
    }

    return true;
}

if (test.txt が存在するか？ == false) {
    test.txt を作成する
}

test.txt をオープンして使う

int rename(const char* old_filename, const char* new_filename);

#include <cstdio>
#include <iostream>
#include <string>

int main()
{
    const std::string old_path {"test.txt"};
    const std::string new_path {"new_test.txt"};
    if (std::rename(old_path.c_str(), new_path.c_str()) == 0) {
        std::cout << "ファイル名を変更しました。\n";
    }
    else {
        std::cerr << old_path << "のリネームに失敗しました。\n";
    }
}

int remove(const char* filename);

#include <cstdio>
#include <iostream>

int main()
{
    if (std::remove("test.bmp") == 0) {
        std::cout << "ファイルを削除しました。\n";
    }
    else {
        std::cout << "ファイルの削除に失敗しました。\n";
    }
}