C++におけるファイル入出力は、プログラムが外部データとやり取りするために不可欠な要素です。さらに、RAII（Resource Acquisition Is Initialization）というリソース管理の手法を用いることで、安全で効率的なコードを記述することが可能になります。本記事では、C++での基本的なファイル入出力方法から、RAIIを活用したリソース管理の実践まで、段階的に解説していきます。
C++でのファイル入出力の基本
C++では、ファイル操作を行うために標準ライブラリのファイルストリームクラス（fstream、ifstream、ofstream）を使用します。これらのクラスを使用することで、テキストファイルやバイナリファイルの読み書きが容易に行えます。以下に基本的な使用方法を示します。
テキストファイルの読み書き
テキストファイルの読み書きには、ifstream（入力ファイルストリーム）とofstream（出力ファイルストリーム）を使用します。以下にその基本的な例を示します。
テキストファイルの書き込み
#include <fstream>
#include <iostream>
int main() {
std::ofstream outFile("example.txt");
if (outFile.is_open()) {
outFile << "This is a line of text.\n";
outFile << "This is another line of text.\n";
outFile.close();
} else {
std::cerr << "Unable to open file for writing";
}
return 0;
}テキストファイルの読み込み
#include <fstream>
#include <iostream>
#include <string>
int main() {
std::ifstream inFile("example.txt");
if (inFile.is_open()) {
std::string line;
while (std::getline(inFile, line)) {
std::cout << line << std::endl;
}
inFile.close();
} else {
std::cerr << "Unable to open file for reading";
}
return 0;
}これらのコード例では、ファイルが正しく開けたかどうかを確認し、開けなかった場合にはエラーメッセージを表示しています。次のセクションでは、ifstreamとofstreamの使い方について詳しく見ていきます。
ifstreamとofstreamの使い方
C++では、ファイルの読み書きを行うためにifstream（入力ファイルストリーム）とofstream（出力ファイルストリーム）を使用します。これらのクラスは、それぞれファイルからのデータ読み込みとファイルへのデータ書き込みを行います。具体的な使い方について詳しく説明します。
ofstreamを用いたファイルの書き込み
ofstreamは、ファイルへの出力（書き込み）を行うためのクラスです。以下に基本的な使用例を示します。
#include <fstream>
#include <iostream>
int main() {
std::ofstream outFile("output.txt");
if (outFile.is_open()) {
outFile << "Hello, World!" << std::endl;
outFile << "Writing to a file in C++." << std::endl;
outFile.close();
} else {
std::cerr << "Unable to open file for writing";
}
return 0;
}この例では、”output.txt”というファイルにテキストを出力しています。ファイルが正常に開かれたかどうかを確認し、開かれていればテキストを書き込み、最後にファイルを閉じます。
ifstreamを用いたファイルの読み込み
ifstreamは、ファイルからの入力（読み込み）を行うためのクラスです。以下に基本的な使用例を示します。
#include <fstream>
#include <iostream>
#include <string>
int main() {
std::ifstream inFile("input.txt");
if (inFile.is_open()) {
std::string line;
while (std::getline(inFile, line)) {
std::cout << line << std::endl;
}
inFile.close();
} else {
std::cerr << "Unable to open file for reading";
}
return 0;
}この例では、”input.txt”というファイルから1行ずつ読み込み、その内容を標準出力に表示しています。ファイルが正常に開かれたかどうかを確認し、開かれていれば各行を読み込んで出力し、最後にファイルを閉じます。
バイナリファイルの読み書き
バイナリファイルを扱う場合、ファイルストリームをバイナリモードで開く必要があります。以下にその例を示します。
バイナリファイルの書き込み
#include <fstream>
#include <iostream>
int main() {
std::ofstream outFile("output.bin", std::ios::binary);
if (outFile.is_open()) {
int number = 12345;
outFile.write(reinterpret_cast<char*>(&number), sizeof(number));
outFile.close();
} else {
std::cerr << "Unable to open file for writing";
}
return 0;
}バイナリファイルの読み込み
#include <fstream>
#include <iostream>
int main() {
std::ifstream inFile("output.bin", std::ios::binary);
if (inFile.is_open()) {
int number;
inFile.read(reinterpret_cast<char*>(&number), sizeof(number));
std::cout << "Read number: " << number << std::endl;
inFile.close();
} else {
std::cerr << "Unable to open file for reading";
}
return 0;
}これらの例では、整数値をバイナリファイルに書き込み、後でそれを読み戻しています。バイナリモードでファイルを開くことで、データがテキスト形式ではなくバイナリ形式で処理されます。次のセクションでは、ファイルストリームのエラーハンドリングについて詳しく説明します。
ファイルストリームのエラーハンドリング
ファイル操作中に発生するエラーを適切に処理することは、信頼性の高いプログラムを作成するために重要です。C++では、ファイルストリームクラス（ifstream、ofstream、fstream）に組み込まれたエラーハンドリング機能を利用して、これらのエラーを処理することができます。
エラーの種類
ファイルストリームでは、以下のようなエラーが発生する可能性があります：
- ファイルを開けない
- ファイルへの書き込み失敗
- ファイルからの読み込み失敗
エラーチェックの基本
ファイル操作中のエラーを検出するために、ファイルストリームオブジェクトのメンバ関数を使用します。
fail() メンバ関数
fail() メンバ関数は、入力または出力操作が失敗したかどうかを確認します。
#include <fstream>
#include <iostream>
int main() {
std::ofstream outFile("output.txt");
if (!outFile) {
std::cerr << "Error: Could not open file for writing." << std::endl;
return 1;
}
outFile << "Hello, World!" << std::endl;
if (outFile.fail()) {
std::cerr << "Error: Write operation failed." << std::endl;
}
outFile.close();
return 0;
}bad() メンバ関数
bad() メンバ関数は、ファイルストリームが致命的なエラー状態にあるかどうかを確認します。
#include <fstream>
#include <iostream>
int main() {
std::ifstream inFile("input.txt");
if (!inFile) {
std::cerr << "Error: Could not open file for reading." << std::endl;
return 1;
}
char ch;
while (inFile.get(ch)) {
if (inFile.bad()) {
std::cerr << "Error: Unrecoverable read error." << std::endl;
break;
}
std::cout << ch;
}
inFile.close();
return 0;
}eof() メンバ関数
eof() メンバ関数は、ファイルの終わりに達したかどうかを確認します。
#include <fstream>
#include <iostream>
int main() {
std::ifstream inFile("input.txt");
if (!inFile) {
std::cerr << "Error: Could not open file for reading." << std::endl;
return 1;
}
char ch;
while (inFile.get(ch)) {
if (inFile.eof()) {
std::cout << "End of file reached." << std::endl;
break;
}
std::cout << ch;
}
inFile.close();
return 0;
}例外を用いたエラーハンドリング
ファイルストリームは例外を投げる設定にすることもできます。これにより、エラー発生時に例外が投げられ、catchブロックで処理できます。
#include <fstream>
#include <iostream>
int main() {
try {
std::ifstream inFile("input.txt");
inFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
if (!inFile) {
throw std::ios_base::failure("Error: Could not open file for reading.");
}
char ch;
while (inFile.get(ch)) {
std::cout << ch;
}
inFile.close();
} catch (const std::ios_base::failure& e) {
std::cerr << "Exception caught: " << e.what() << std::endl;
}
return 0;
}この例では、ファイルを開けなかったり読み込み中にエラーが発生した場合に、例外が投げられ、catchブロックでそのエラーを処理します。次のセクションでは、RAIIの概念とその重要性について説明します。
RAIIとは何か
RAII（Resource Acquisition Is Initialization）は、C++でリソース管理を行うための重要な概念です。この手法により、リソースの確保と解放を自動的に管理し、メモリリークやリソースリークを防ぐことができます。RAIIの基本原則とその利点について詳しく見ていきましょう。
RAIIの基本原則
RAIIは、オブジェクトのライフタイムとリソース管理を密接に結びつけることを目的としています。具体的には、リソース（メモリ、ファイルハンドル、ネットワーク接続など）の取得をオブジェクトの初期化（コンストラクタ）時に行い、リソースの解放をオブジェクトの破棄（デストラクタ）時に行います。
RAIIの具体例
以下のコードは、RAIIの基本的な使用例です。
#include <iostream>
class Resource {
public:
Resource() {
// リソースの取得
std::cout << "Resource acquired\n";
}
~Resource() {
// リソースの解放
std::cout << "Resource released\n";
}
};
int main() {
{
Resource res;
// リソースを使用
}
// resのライフタイム終了時にリソースが自動的に解放される
return 0;
}この例では、Resourceクラスのオブジェクトがスコープを抜けるときにデストラクタが呼び出され、リソースが解放されます。
RAIIの利点
RAIIを使用することで、以下の利点があります。
リソースリークの防止
RAIIは、リソースの取得と解放を確実に行うため、メモリリークやファイルハンドルリークなどのリソースリークを防止します。
例外安全性の向上
例外が発生しても、デストラクタが確実に呼び出されるため、リソースが適切に解放されます。これにより、コードの例外安全性が向上します。
コードの簡潔化
リソース管理をクラスに委ねることで、コードが簡潔になり、可読性が向上します。また、リソース管理に関するバグが減少します。
次のセクションでは、C++でのRAIIパターンの実装例について詳しく説明します。
C++でのRAIIパターンの実装例
RAIIパターンを実装することで、リソース管理を自動化し、コードの安全性と可読性を向上させることができます。以下に、C++でのRAIIパターンの具体的な実装例を示します。
ファイルハンドルの管理
ファイル操作において、ファイルハンドルの管理をRAIIパターンで実装する例を紹介します。この例では、ファイルを開き、スコープを抜けると自動的にファイルを閉じるクラスを作成します。
#include <fstream>
#include <iostream>
class FileHandler {
public:
FileHandler(const std::string& filename) : file(filename) {
if (!file.is_open()) {
throw std::ios_base::failure("Failed to open file");
}
std::cout << "File opened: " << filename << std::endl;
}
~FileHandler() {
if (file.is_open()) {
file.close();
std::cout << "File closed" << std::endl;
}
}
std::ofstream& getStream() {
return file;
}
private:
std::ofstream file;
};
int main() {
try {
FileHandler fh("example.txt");
fh.getStream() << "Hello, RAII!" << std::endl;
} catch (const std::ios_base::failure& e) {
std::cerr << "Exception: " << e.what() << std::endl;
}
return 0;
}この例では、FileHandlerクラスがコンストラクタでファイルを開き、デストラクタで自動的にファイルを閉じます。これにより、ファイルの開閉を確実に行うことができます。
メモリ管理
RAIIパターンはメモリ管理にも応用できます。以下に、動的メモリをRAIIパターンで管理する例を示します。
#include <iostream>
#include <memory>
class MemoryBlock {
public:
MemoryBlock(size_t size) : size(size), data(new int[size]) {
std::cout << "MemoryBlock of size " << size << " created" << std::endl;
}
~MemoryBlock() {
delete[] data;
std::cout << "MemoryBlock of size " << size << " destroyed" << std::endl;
}
int* getData() const {
return data;
}
private:
size_t size;
int* data;
};
int main() {
{
std::unique_ptr<MemoryBlock> memBlock(new MemoryBlock(10));
int* data = memBlock->getData();
for (size_t i = 0; i < 10; ++i) {
data[i] = i * i;
}
}
// メモリブロックのライフタイム終了時に自動的にメモリが解放される
return 0;
}この例では、MemoryBlockクラスが動的に割り当てられたメモリを管理し、デストラクタで自動的に解放します。std::unique_ptrを使用することで、RAIIをさらに強化しています。
ネットワーク接続の管理
ネットワーク接続の管理にもRAIIパターンを適用できます。以下に、ネットワークソケットの接続と切断を管理する例を示します。
#include <iostream>
#include <stdexcept>
// 疑似的なSocketクラスの例
class Socket {
public:
Socket(const std::string& address) {
// ソケットの接続処理
std::cout << "Connecting to " << address << std::endl;
connected = true;
}
~Socket() {
if (connected) {
// ソケットの切断処理
std::cout << "Disconnecting socket" << std::endl;
}
}
void send(const std::string& message) {
if (!connected) {
throw std::runtime_error("Socket is not connected");
}
std::cout << "Sending message: " << message << std::endl;
}
private:
bool connected = false;
};
int main() {
try {
Socket socket("192.168.1.1");
socket.send("Hello, network!");
} catch (const std::runtime_error& e) {
std::cerr << "Exception: " << e.what() << std::endl;
}
return 0;
}この例では、Socketクラスがネットワーク接続を管理し、オブジェクトのライフタイム終了時に自動的に接続を切断します。これにより、ネットワークリソースの管理が容易になります。
次のセクションでは、スマートポインタとRAIIについて詳しく説明します。
スマートポインタとRAII
C++11以降、スマートポインタを使用することで、RAIIの原則をより簡単に実現できるようになりました。スマートポインタは、メモリ管理を自動化し、リソースリークを防ぐための強力なツールです。以下では、スマートポインタの基本とその具体例を紹介します。
スマートポインタの基本
スマートポインタは、ポインタのライフサイクルを管理し、メモリの自動解放を実現します。標準ライブラリには、std::unique_ptr、std::shared_ptr、std::weak_ptrの3種類のスマートポインタが含まれています。
std::unique_ptr
std::unique_ptrは、所有権の一意性を保証するスマートポインタです。std::unique_ptrの所有するオブジェクトは、他のstd::unique_ptrに所有権を移動（ムーブ）することができますが、複製（コピー）はできません。
#include <iostream>
#include <memory>
class Resource {
public:
Resource() {
std::cout << "Resource acquired\n";
}
~Resource() {
std::cout << "Resource released\n";
}
void doSomething() {
std::cout << "Doing something\n";
}
};
int main() {
std::unique_ptr<Resource> res = std::make_unique<Resource>();
res->doSomething();
// 所有権の移動
std::unique_ptr<Resource> res2 = std::move(res);
if (res == nullptr) {
std::cout << "res is null\n";
}
res2->doSomething();
return 0;
}std::shared_ptr
std::shared_ptrは、複数の所有者が存在するスマートポインタです。std::shared_ptrは、参照カウントを使用してオブジェクトのライフタイムを管理し、すべての所有者が解放されたときにオブジェクトを削除します。
#include <iostream>
#include <memory>
class Resource {
public:
Resource() {
std::cout << "Resource acquired\n";
}
~Resource() {
std::cout << "Resource released\n";
}
void doSomething() {
std::cout << "Doing something\n";
}
};
void useResource(std::shared_ptr<Resource> res) {
res->doSomething();
}
int main() {
std::shared_ptr<Resource> res1 = std::make_shared<Resource>();
{
std::shared_ptr<Resource> res2 = res1;
useResource(res2);
}
// res1がまだ所有しているため、Resourceは解放されない
res1->doSomething();
return 0;
}std::weak_ptr
std::weak_ptrは、std::shared_ptrの循環参照を防ぐために使用されるスマートポインタです。std::weak_ptrは所有権を持たないため、参照カウントに影響を与えません。
#include <iostream>
#include <memory>
class Resource;
class Owner {
public:
std::shared_ptr<Resource> resource;
~Owner() {
std::cout << "Owner destroyed\n";
}
};
class Resource {
public:
std::weak_ptr<Owner> owner;
~Resource() {
std::cout << "Resource destroyed\n";
}
};
int main() {
std::shared_ptr<Owner> owner = std::make_shared<Owner>();
std::shared_ptr<Resource> resource = std::make_shared<Resource>();
owner->resource = resource;
resource->owner = owner;
// この時点で循環参照は発生しない
std::cout << "End of scope\n";
return 0;
}スマートポインタを使ったRAIIの利点
スマートポインタを使用することで、以下の利点が得られます：
メモリリークの防止
スマートポインタは、オブジェクトのライフタイムを管理し、不要になったオブジェクトを自動的に解放するため、メモリリークを防止します。
例外安全性の向上
例外が発生しても、スマートポインタが適切にリソースを解放するため、コードの例外安全性が向上します。
コードの簡潔化
スマートポインタを使用することで、リソース管理コードが簡潔になり、可読性が向上します。
次のセクションでは、RAIIと例外処理の関係について詳しく説明します。
RAIIと例外処理の関係
RAII（Resource Acquisition Is Initialization）は、例外処理と密接に関係しています。RAIIを使用することで、例外が発生した場合でも確実にリソースが解放され、コードの安全性と信頼性が向上します。以下では、RAIIと例外処理の関係について詳しく説明します。
例外安全性とは
例外安全性（Exception Safety）とは、プログラムが例外発生時にも予測可能な状態を保ち、適切にリソースを管理する能力を指します。C++では、例外が発生してもリソースリークを防ぐためにRAIIが広く使用されています。
RAIIによる例外安全なコードの実装
RAIIを使用すると、例外が発生してもデストラクタが確実に呼び出されるため、リソースが適切に解放されます。以下に、RAIIを使用した例外安全なコードの例を示します。
RAIIを用いたリソース管理
#include <iostream>
#include <fstream>
#include <memory>
class FileHandler {
public:
FileHandler(const std::string& filename) : file(new std::ofstream(filename)) {
if (!file->is_open()) {
throw std::ios_base::failure("Failed to open file");
}
std::cout << "File opened: " << filename << std::endl;
}
~FileHandler() {
if (file->is_open()) {
file->close();
std::cout << "File closed" << std::endl;
}
}
std::ofstream& getStream() {
return *file;
}
private:
std::unique_ptr<std::ofstream> file;
};
int main() {
try {
FileHandler fh("example.txt");
fh.getStream() << "Hello, RAII with exceptions!" << std::endl;
// ここで例外を投げる
throw std::runtime_error("An error occurred");
} catch (const std::exception& e) {
std::cerr << "Exception: " << e.what() << std::endl;
}
// FileHandlerのデストラクタが呼び出され、ファイルが閉じられる
return 0;
}この例では、FileHandlerクラスがファイルを管理し、例外が発生してもデストラクタによってファイルが確実に閉じられます。
スマートポインタと例外処理
スマートポインタ（std::unique_ptrやstd::shared_ptr）は、RAIIの原則をサポートし、例外が発生してもリソースを自動的に解放します。これにより、メモリリークを防ぎ、コードの例外安全性を向上させます。
std::unique_ptrによる例外安全なメモリ管理
#include <iostream>
#include <memory>
class Resource {
public:
Resource() {
std::cout << "Resource acquired\n";
}
~Resource() {
std::cout << "Resource released\n";
}
void doSomething() {
std::cout << "Doing something\n";
}
};
int main() {
try {
std::unique_ptr<Resource> res = std::make_unique<Resource>();
res->doSomething();
// ここで例外を投げる
throw std::runtime_error("An unexpected error");
} catch (const std::exception& e) {
std::cerr << "Exception: " << e.what() << std::endl;
}
// std::unique_ptrのデストラクタが呼び出され、リソースが解放される
return 0;
}この例では、std::unique_ptrを使用してResourceオブジェクトを管理し、例外が発生しても確実にリソースが解放されます。
RAIIとスコープ管理
RAIIのもう一つの重要な側面は、スコープによるリソース管理です。オブジェクトがスコープを抜けるときにデストラクタが呼び出されるため、リソースが自動的に解放されます。これにより、例外が発生してもリソースリークが防止されます。
#include <iostream>
class Resource {
public:
Resource() {
std::cout << "Resource acquired\n";
}
~Resource() {
std::cout << "Resource released\n";
}
};
void process() {
Resource res;
// リソースを使用
std::cout << "Processing resource\n";
// ここで例外を投げる
throw std::runtime_error("Processing error");
// リソースの解放は自動的に行われる
}
int main() {
try {
process();
} catch (const std::exception& e) {
std::cerr << "Exception: " << e.what() << std::endl;
}
return 0;
}この例では、process関数内でResourceオブジェクトがスコープを抜けるときに自動的に解放されます。これにより、例外が発生してもリソースが確実に解放されます。
次のセクションでは、ファイル入出力とRAIIを組み合わせた応用例について説明します。
応用例：ファイル入出力とRAIIの組み合わせ
ファイル入出力とRAIIを組み合わせることで、より安全で効率的なコードを作成できます。ここでは、実際の応用例として、ファイル入出力操作をRAIIパターンで管理する方法を紹介します。
ファイル操作クラスの実装
以下の例では、ファイルの読み書きをRAIIで管理するFileHandlerクラスを実装します。このクラスは、ファイルのオープンとクローズを自動的に行い、エラー処理も組み込んでいます。
#include <fstream>
#include <iostream>
#include <string>
class FileHandler {
public:
FileHandler(const std::string& filename, std::ios::openmode mode)
: file(filename, mode) {
if (!file.is_open()) {
throw std::ios_base::failure("Failed to open file: " + filename);
}
std::cout << "File opened: " << filename << std::endl;
}
~FileHandler() {
if (file.is_open()) {
file.close();
std::cout << "File closed" << std::endl;
}
}
std::fstream& getStream() {
return file;
}
private:
std::fstream file;
};
int main() {
try {
// ファイルへの書き込み
{
FileHandler fileWriter("example.txt", std::ios::out);
fileWriter.getStream() << "Hello, RAII with file I/O!" << std::endl;
}
// ファイルからの読み込み
{
FileHandler fileReader("example.txt", std::ios::in);
std::string line;
while (std::getline(fileReader.getStream(), line)) {
std::cout << line << std::endl;
}
}
} catch (const std::ios_base::failure& e) {
std::cerr << "File operation error: " << e.what() << std::endl;
}
return 0;
}この例では、FileHandlerクラスがファイルのオープンとクローズを自動的に管理します。ファイル操作がスコープを抜けるときにデストラクタが呼び出され、ファイルが閉じられます。これにより、リソースリークを防ぎ、例外が発生しても安全にリソースを管理できます。
RAIIを用いたログファイル管理
次に、RAIIを利用してログファイルの管理を行う例を示します。この例では、ログファイルを開いてメッセージを書き込み、プログラムの終了時に自動的にログファイルを閉じます。
#include <fstream>
#include <iostream>
#include <string>
class Logger {
public:
Logger(const std::string& filename)
: logFile(filename, std::ios::app) {
if (!logFile.is_open()) {
throw std::ios_base::failure("Failed to open log file: " + filename);
}
std::cout << "Log file opened: " << filename << std::endl;
}
~Logger() {
if (logFile.is_open()) {
logFile.close();
std::cout << "Log file closed" << std::endl;
}
}
void log(const std::string& message) {
if (logFile.is_open()) {
logFile << message << std::endl;
}
}
private:
std::ofstream logFile;
};
int main() {
try {
Logger logger("logfile.txt");
logger.log("Program started");
// プログラムの処理
logger.log("Processing data...");
logger.log("Program ended successfully");
} catch (const std::ios_base::failure& e) {
std::cerr << "Logging error: " << e.what() << std::endl;
}
return 0;
}この例では、Loggerクラスがログファイルの管理を行います。プログラムの実行中にログメッセージをファイルに書き込み、プログラムの終了時にファイルが自動的に閉じられます。
スマートポインタを用いたリソース管理
RAIIをスマートポインタと組み合わせることで、さらに強力なリソース管理が可能になります。以下に、スマートポインタを使用してファイル操作を行う例を示します。
#include <iostream>
#include <memory>
#include <fstream>
class FileHandler {
public:
FileHandler(const std::string& filename, std::ios::openmode mode)
: file(std::make_unique<std::fstream>(filename, mode)) {
if (!file->is_open()) {
throw std::ios_base::failure("Failed to open file: " + filename);
}
std::cout << "File opened: " << filename << std::endl;
}
~FileHandler() {
if (file->is_open()) {
file->close();
std::cout << "File closed" << std::endl;
}
}
std::fstream& getStream() {
return *file;
}
private:
std::unique_ptr<std::fstream> file;
};
int main() {
try {
{
FileHandler writer("example.txt", std::ios::out);
writer.getStream() << "Hello, RAII with smart pointers!" << std::endl;
}
{
FileHandler reader("example.txt", std::ios::in);
std::string line;
while (std::getline(reader.getStream(), line)) {
std::cout << line << std::endl;
}
}
} catch (const std::ios_base::failure& e) {
std::cerr << "File operation error: " << e.what() << std::endl;
}
return 0;
}この例では、std::unique_ptrを使用してファイルストリームを管理し、例外が発生しても確実にリソースが解放されます。
次のセクションでは、学習を深めるための演習問題を提供します。
演習問題
ここでは、C++でのファイル入出力とRAIIに関する理解を深めるための演習問題を提供します。これらの問題に取り組むことで、実践的なスキルを磨くことができます。
演習1: 基本的なファイル入出力
- テキストファイル”data.txt”を作成し、以下の内容を書き込んでください。
Hello, C++!
Welcome to file I/O.- 書き込んだファイルを読み込み、その内容をコンソールに出力してください。
ヒント
- ofstreamを使用してファイルに書き込み、ifstreamを使用してファイルから読み込みます。
解答例
#include <fstream>
#include <iostream>
#include <string>
int main() {
// ファイルに書き込む
std::ofstream outFile("data.txt");
if (outFile.is_open()) {
outFile << "Hello, C++!\n";
outFile << "Welcome to file I/O.\n";
outFile.close();
} else {
std::cerr << "Unable to open file for writing\n";
}
// ファイルから読み込む
std::ifstream inFile("data.txt");
if (inFile.is_open()) {
std::string line;
while (std::getline(inFile, line)) {
std::cout << line << std::endl;
}
inFile.close();
} else {
std::cerr << "Unable to open file for reading\n";
}
return 0;
}演習2: RAIIによるファイル管理クラスの作成
- ファイルを管理するRAIIクラス”FileManager”を作成し、そのコンストラクタでファイルを開き、デストラクタでファイルを閉じるように実装してください。
- このクラスを使用して、”log.txt”ファイルにログメッセージを追加してください。
ヒント
- std::fstreamを使用し、クラス内でファイルの開閉を管理します。
解答例
#include <fstream>
#include <iostream>
#include <string>
class FileManager {
public:
FileManager(const std::string& filename, std::ios::openmode mode)
: file(filename, mode) {
if (!file.is_open()) {
throw std::ios_base::failure("Failed to open file: " + filename);
}
std::cout << "File opened: " << filename << std::endl;
}
~FileManager() {
if (file.is_open()) {
file.close();
std::cout << "File closed" << std::endl;
}
}
std::fstream& getStream() {
return file;
}
private:
std::fstream file;
};
int main() {
try {
FileManager logFile("log.txt", std::ios::app);
logFile.getStream() << "Program started\n";
logFile.getStream() << "Logging some actions\n";
logFile.getStream() << "Program ended\n";
} catch (const std::ios_base::failure& e) {
std::cerr << "File operation error: " << e.what() << std::endl;
}
return 0;
}演習3: スマートポインタとRAIIの応用
- std::unique_ptrを使用して、動的に割り当てられたメモリを管理するクラスを作成してください。このクラスは整数の配列を動的に割り当て、デストラクタで解放します。
- このクラスを使用して、配列に値を設定し、その内容をコンソールに出力してください。
ヒント
- std::unique_ptrを使用します。
解答例
#include <iostream>
#include <memory>
class IntArrayManager {
public:
IntArrayManager(size_t size)
: size(size), data(std::make_unique<int[]>(size)) {
std::cout << "Array of size " << size << " created" << std::endl;
}
~IntArrayManager() {
std::cout << "Array destroyed" << std::endl;
}
int* getData() const {
return data.get();
}
private:
size_t size;
std::unique_ptr<int[]> data;
};
int main() {
IntArrayManager arr(10);
int* data = arr.getData();
for (size_t i = 0; i < 10; ++i) {
data[i] = i * i;
}
for (size_t i = 0; i < 10; ++i) {
std::cout << data[i] << " ";
}
std::cout << std::endl;
return 0;
}これらの演習問題を通じて、C++でのファイル入出力とRAIIの実践的なスキルを身につけることができます。次のセクションでは、この記事のまとめを行います。
まとめ
この記事では、C++におけるファイル入出力とRAII（Resource Acquisition Is Initialization）について詳しく解説しました。基本的なファイル操作方法から始まり、RAIIの概念とその実装例、スマートポインタを用いたリソース管理の方法、そして例外処理との関係について説明しました。
RAIIは、リソース管理を自動化し、例外が発生しても安全にリソースを解放する強力な手法です。これにより、メモリリークやリソースリークを防ぎ、コードの安全性と可読性を向上させることができます。さらに、スマートポインタを活用することで、複雑なリソース管理をシンプルかつ安全に行うことが可能です。
提供した演習問題を通じて、実践的なスキルを磨き、C++でのファイル入出力とRAIIの理解を深めることができたでしょう。この記事が、より安全で効率的なC++プログラミングの実践に役立つことを願っています。
コメント