C++におけるオブジェクト指向プログラミングの基礎
Java と Python とは異なる C++ のオブジェクト指向の特徴
C++は、高性能なシステム開発からアプリケーション開発まで幅広く使用されるマルチパラダイム言語です。Java や Python と比較して、以下のような独自の特徴を持っています：
- メモリ管理の直接制御
class ResourceManager {
private:
int* data; // 生ポインタ
public:
ResourceManager() : data(new int[100]) { // コンストラクタでメモリ確保
// 初期化処理
}
~ResourceManager() { // デストラクタで自動解放
delete[] data;
}
};
- 多重継承のサポート
class Interface1 {
public:
virtual void method1() = 0; // 純粋仮想関数
};
class Interface2 {
public:
virtual void method2() = 0;
};
class Implementation : public Interface1, public Interface2 { // 複数のインターフェースを実装
public:
void method1() override { /* 実装 */ }
void method2() override { /* 実装 */ }
};
- パフォーマンス最適化の柔軟性
class OptimizedClass {
private:
std::vector<int> data;
public:
void reserveSpace(size_t size) {
data.reserve(size); // メモリ事前確保による最適化
}
void processInPlace() {
// データを直接操作可能
}
};
オブジェクト指向の4つの大要素をC++で実現する方法
- カプセル化
カプセル化は、データと操作をひとつのユニットにまとめ、外部からのアクセスを制御する機能です。
class BankAccount {
private: // プライベートメンバ（カプセル化）
double balance;
std::string accountNumber;
protected: // 継承クラスからのみアクセス可能
void updateBalance(double amount);
public: // パブリックインターフェース
BankAccount(const std::string& accNum);
double getBalance() const;
void deposit(double amount);
bool withdraw(double amount);
};
- 継承
C++では、単一継承と多重継承の両方をサポートしています。
class Shape {
public:
virtual double area() const = 0; // 純粋仮想関数
virtual double perimeter() const = 0;
};
class Rectangle : public Shape {
private:
double width, height;
public:
Rectangle(double w, double h) : width(w), height(h) {}
double area() const override {
return width * height;
}
double perimeter() const override {
return 2 * (width + height);
}
};
- ポリモーフィズム
C++では、仮想関数を使用して実行時ポリモーフィズムを実現します。
void processShape(const Shape& shape) {
std::cout << "面積: " << shape.area() << std::endl;
std::cout << "周長: " << shape.perimeter() << std::endl;
}
int main() {
Rectangle rect(5.0, 3.0);
Circle circle(2.5);
processShape(rect); // Rectangle用の実装が呼ばれる
processShape(circle); // Circle用の実装が呼ばれる
}
- 抽象化
抽象クラスと純粋仮想関数を使用して、インターフェースを定義します。
class Database { // 抽象クラス
public:
virtual void connect() = 0; // 純粋仮想関数
virtual void disconnect() = 0;
virtual bool execute(const std::string& query) = 0;
virtual ~Database() {} // 仮想デストラクタ
};
class MySQLDatabase : public Database {
public:
void connect() override {
// MySQL固有の接続処理
}
// その他のメソッド実装
};
これらの要素を適切に組み合わせることで、保守性が高く、再利用可能なC++コードを作成することができます。特に、C++ではメモリ管理の直接制御が可能なため、パフォーマンスを最適化しつつ、オブジェクト指向の利点を最大限に活用できます。
C++でのクラスとオブジェクトの実装方法
クラス定義とメンバ変数の適切なカプセル化
C++でクラスを設計する際は、適切なカプセル化を通じてデータの整合性を保護し、クラスの責務を明確にすることが重要です。
- アクセス指定子の戦略的な使用
class Employee {
private: // デフォルトでprivate
std::string name_; // メンバ変数には '_' サフィックスを付けることが多い
double salary_;
int employeeId_;
protected: // 派生クラスからアクセス可能
void updateSalary(double newSalary);
public: // 外部からアクセス可能なインターフェース
// constメンバ関数によるデータ参照
std::string getName() const { return name_; }
double getSalary() const { return salary_; }
// 値の検証を含むセッター
void setName(const std::string& name) {
if (!name.empty()) {
name_ = name;
}
}
};
- モダンC++でのカプセル化のベストプラクティス
class DataContainer {
private:
std::vector<int> data_;
mutable std::mutex mutex_; // constメンバ関数でも変更可能
public:
// スレッドセーフなデータアクセス
void addData(int value) {
std::lock_guard<std::mutex> lock(mutex_);
data_.push_back(value);
}
// const参照による効率的なデータ共有
const std::vector<int>& getData() const {
std::lock_guard<std::mutex> lock(mutex_);
return data_;
}
};
コンストラクタとデストラクタの重要性と実装例
- 各種コンストラクタの実装
class ResourceHolder {
private:
std::string* data_;
size_t size_;
public:
// デフォルトコンストラクタ
ResourceHolder() : data_(nullptr), size_(0) {}
// パラメータ付きコンストラクタ（初期化リスト使用）
ResourceHolder(const std::string& str)
: data_(new std::string(str))
, size_(str.length()) {
}
// コピーコンストラクタ
ResourceHolder(const ResourceHolder& other)
: data_(new std::string(*other.data_))
, size_(other.size_) {
}
// ムーブコンストラクタ
ResourceHolder(ResourceHolder&& other) noexcept
: data_(other.data_)
, size_(other.size_) {
other.data_ = nullptr; // 移動元のリソースをクリア
other.size_ = 0;
}
// デストラクタ
~ResourceHolder() {
delete data_; // リソースの解放
}
// コピー代入演算子
ResourceHolder& operator=(const ResourceHolder& other) {
if (this != &other) { // 自己代入チェック
delete data_; // 既存リソースの解放
data_ = new std::string(*other.data_);
size_ = other.size_;
}
return *this;
}
// ムーブ代入演算子
ResourceHolder& operator=(ResourceHolder&& other) noexcept {
if (this != &other) {
delete data_;
data_ = other.data_;
size_ = other.size_;
other.data_ = nullptr;
other.size_ = 0;
}
return *this;
}
};
- RAIIパターンを活用したリソース管理
class FileHandler {
private:
std::unique_ptr<std::ifstream> file_; // スマートポインタによる自動リソース管理
std::string filename_;
public:
// コンストラクタでファイルを開く
FileHandler(const std::string& filename)
: filename_(filename)
, file_(std::make_unique<std::ifstream>(filename)) {
if (!file_->is_open()) {
throw std::runtime_error("Failed to open file: " + filename);
}
}
// デストラクタで自動的にファイルが閉じられる
// unique_ptrのデストラクタが呼ばれる
~FileHandler() = default;
// ムーブ可能だがコピー不可
FileHandler(FileHandler&&) = default;
FileHandler& operator=(FileHandler&&) = default;
FileHandler(const FileHandler&) = delete;
FileHandler& operator=(const FileHandler&) = delete;
};
これらの実装例は、C++でのオブジェクト指向プログラミングの基本的な考え方を示しています。適切なカプセル化とリソース管理を行うことで、安全で保守性の高いコードを作成することができます。特に、モダンC++では、スマートポインタやムーブセマンティクスを活用することで、より安全で効率的なリソース管理が可能になっています。
C++特有のメモリ管理とオブジェクトライフサイクル
スタックとヒープのオブジェクト管理の違い
C++におけるメモリ管理の基本は、スタックとヒープの適切な使い分けです。それぞれの特徴を理解し、適切に選択することでパフォーマンスと安全性を両立できます。
- スタックメモリの特徴と活用
class Point {
double x_, y_;
public:
Point(double x, double y) : x_(x), y_(y) {}
double getDistance() const {
return std::sqrt(x_ * x_ + y_ * y_);
}
};
void stackExample() {
// スタック上にオブジェクトを作成
Point p1(3.0, 4.0); // 自動的にスコープ終了時に破棄
// 配列もスタック上に確保可能
Point points[100] = { Point(0,0) }; // サイズが固定の場合
// スコープを抜けると自動的に破棄される
} // p1とpointsが自動的に破棄
- ヒープメモリの管理とライフサイクル
class LargeObject {
std::vector<double> data_;
public:
LargeObject(size_t size) : data_(size) {}
void process() { /* データ処理 */ }
};
void heapExample() {
// 従来のヒープ管理（非推奨）
LargeObject* obj1 = new LargeObject(1000000);
try {
obj1->process();
}
catch (...) {
delete obj1; // 例外時にもリソース解放
throw;
}
delete obj1; // 明示的な解放が必要
// モダンなヒープ管理（推奨）
auto obj2 = std::make_unique<LargeObject>(1000000);
obj2->process(); // 例外が発生しても自動的に解放される
} // obj2は自動的に解放
スマートポインタを使用した安全なオブジェクト管理
- unique_ptrによる排他的所有権管理
class Resource {
public:
void doWork() { std::cout << "Working...\n"; }
};
class ResourceManager {
private:
std::unique_ptr<Resource> resource_;
public:
ResourceManager() : resource_(std::make_unique<Resource>()) {}
// ムーブは可能
ResourceManager(ResourceManager&& other) = default;
// コピーは禁止
ResourceManager(const ResourceManager&) = delete;
ResourceManager& operator=(const ResourceManager&) = delete;
void useResource() {
if (resource_) {
resource_->doWork();
}
}
};
- shared_ptrによる共有所有権管理
class SharedResource {
public:
void doWork() { std::cout << "Shared working...\n"; }
};
class Worker {
private:
std::shared_ptr<SharedResource> resource_;
public:
Worker(const std::shared_ptr<SharedResource>& resource)
: resource_(resource) {}
void work() {
if (resource_) {
resource_->doWork();
std::cout << "Reference count: "
<< resource_.use_count() << "\n";
}
}
};
// 使用例
void sharedPtrExample() {
auto resource = std::make_shared<SharedResource>();
Worker worker1(resource);
Worker worker2(resource);
worker1.work(); // Reference count: 3
worker2.work(); // Reference count: 3
} // resourceは全ての参照がなくなると自動解放
- weak_ptrによる循環参照の防止
class Node {
private:
std::shared_ptr<Node> next_; // 強い参照
std::weak_ptr<Node> previous_; // 弱い参照
int data_;
public:
Node(int data) : data_(data) {}
void setNext(const std::shared_ptr<Node>& next) {
next_ = next;
}
void setPrevious(const std::shared_ptr<Node>& prev) {
previous_ = prev; // 弱い参照として保持
}
void processNode() {
if (auto prev = previous_.lock()) { // 弱い参照をロック
// previousノードが存在する場合の処理
std::cout << "Previous data: " << prev->data_ << "\n";
}
if (next_) {
std::cout << "Next data: " << next_->data_ << "\n";
}
}
};
- カスタムデリータの実装
template<typename T>
struct CustomDeleter {
void operator()(T* ptr) {
// カスタムのクリーンアップ処理
std::cout << "Custom cleanup...\n";
delete ptr;
}
};
void customDeleterExample() {
// カスタムデリータを使用したunique_ptr
std::unique_ptr<Resource, CustomDeleter<Resource>>
ptr(new Resource());
// ファイルハンドルなどのリソース管理
auto fileDeleter = [](FILE* fp) {
if (fp) fclose(fp);
};
std::unique_ptr<FILE, decltype(fileDeleter)>
file(fopen("test.txt", "r"), fileDeleter);
}
C++でのメモリ管理は、適切なスマートポインタの選択と使用により、大幅に安全性を向上させることができます。特に、unique_ptrとshared_ptrを状況に応じて使い分け、必要に応じてweak_ptrを活用することで、メモリリークや循環参照などの問題を効果的に防ぐことができます。また、スタックとヒープの特性を理解し、適切に使い分けることで、パフォーマンスの最適化も実現できます。
継承と多態性の実践的な活用法
単一継承と多重継承の活用
C++の継承機能を効果的に活用することで、コードの再利用性と拡張性を高めることができます。
- 単一継承の基本パターン
class Device {
protected:
std::string name_;
bool powered_;
public:
Device(const std::string& name)
: name_(name), powered_(false) {}
virtual ~Device() = default; // 仮想デストラクタ
virtual void powerOn() {
powered_ = true;
std::cout << name_ << " powered on\n";
}
virtual void powerOff() {
powered_ = false;
std::cout << name_ << " powered off\n";
}
virtual void status() const {
std::cout << name_ << " is "
<< (powered_ ? "on" : "off") << "\n";
}
};
class Printer : public Device {
private:
int pagesInTray_;
public:
Printer(const std::string& name, int pages)
: Device(name), pagesInTray_(pages) {}
void print(const std::string& document) {
if (!powered_) {
std::cout << "Printer is off!\n";
return;
}
if (pagesInTray_ > 0) {
std::cout << "Printing: " << document << "\n";
--pagesInTray_;
}
}
void status() const override {
Device::status();
std::cout << "Pages in tray: " << pagesInTray_ << "\n";
}
};
- 多重継承の実装
class NetworkEnabled {
public:
virtual ~NetworkEnabled() = default;
virtual void connect() = 0;
virtual void disconnect() = 0;
virtual bool isConnected() const = 0;
};
class USBEnabled {
public:
virtual ~USBEnabled() = default;
virtual void plugIn() = 0;
virtual void unplug() = 0;
virtual bool isPlugged() const = 0;
};
class NetworkPrinter
: public Printer
, public NetworkEnabled
, public USBEnabled {
private:
bool networkConnected_;
bool usbConnected_;
public:
NetworkPrinter(const std::string& name, int pages)
: Printer(name, pages)
, networkConnected_(false)
, usbConnected_(false) {}
// NetworkEnabled インターフェースの実装
void connect() override {
networkConnected_ = true;
std::cout << "Network connected\n";
}
void disconnect() override {
networkConnected_ = false;
std::cout << "Network disconnected\n";
}
bool isConnected() const override {
return networkConnected_;
}
// USBEnabled インターフェースの実装
void plugIn() override {
usbConnected_ = true;
std::cout << "USB plugged in\n";
}
void unplug() override {
usbConnected_ = false;
std::cout << "USB unplugged\n";
}
bool isPlugged() const override {
return usbConnected_;
}
};
仮想関数とポリモーフィズムの実装
- 純粋仮想関数によるインターフェース定義
class Shape {
public:
virtual ~Shape() = default;
virtual double area() const = 0; // 純粋仮想関数
virtual double perimeter() const = 0; // 純粋仮想関数
virtual void draw() const = 0; // 純粋仮想関数
};
class Circle : public Shape {
private:
double radius_;
public:
explicit Circle(double radius) : radius_(radius) {}
double area() const override {
return M_PI * radius_ * radius_;
}
double perimeter() const override {
return 2 * M_PI * radius_;
}
void draw() const override {
std::cout << "Drawing Circle with radius "
<< radius_ << "\n";
}
};
class Rectangle : public Shape {
private:
double width_;
double height_;
public:
Rectangle(double width, double height)
: width_(width), height_(height) {}
double area() const override {
return width_ * height_;
}
double perimeter() const override {
return 2 * (width_ + height_);
}
void draw() const override {
std::cout << "Drawing Rectangle " << width_
<< "x" << height_ << "\n";
}
};
- 仮想関数テーブルと動的ディスパッチの活用
class ShapeProcessor {
public:
static void processShapes(const std::vector<std::unique_ptr<Shape>>& shapes) {
double totalArea = 0.0;
double totalPerimeter = 0.0;
for (const auto& shape : shapes) {
// 動的ディスパッチにより適切なメソッドが呼ばれる
shape->draw();
totalArea += shape->area();
totalPerimeter += shape->perimeter();
}
std::cout << "Total Area: " << totalArea << "\n";
std::cout << "Total Perimeter: " << totalPerimeter << "\n";
}
};
// 使用例
void shapeExample() {
std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Circle>(5.0));
shapes.push_back(std::make_unique<Rectangle>(4.0, 6.0));
ShapeProcessor::processShapes(shapes);
}
- 仮想継承による菱形継承問題の解決
class Animal {
protected:
std::string name_;
public:
explicit Animal(const std::string& name) : name_(name) {}
virtual ~Animal() = default;
virtual void eat() = 0;
};
class Flying : virtual public Animal {
public:
Flying(const std::string& name) : Animal(name) {}
virtual void fly() = 0;
};
class Swimming : virtual public Animal {
public:
Swimming(const std::string& name) : Animal(name) {}
virtual void swim() = 0;
};
class Duck : public Flying, public Swimming {
public:
Duck(const std::string& name)
: Animal(name) // 一度だけ基底クラスを初期化
, Flying(name)
, Swimming(name) {}
void eat() override {
std::cout << name_ << " is eating\n";
}
void fly() override {
std::cout << name_ << " is flying\n";
}
void swim() override {
std::cout << name_ << " is swimming\n";
}
};
これらの実装例は、C++における継承と多態性の実践的な活用方法を示しています。特に、仮想関数を使用した動的ディスパッチと、多重継承における問題回避のテクニックは、大規模なオブジェクト指向システムの設計において重要な役割を果たします。また、適切なインターフェース設計と継承の使用により、コードの再利用性と保守性を大幅に向上させることができます。
現場で使えるオブジェクト指向設計パターン
C++で実装する主要なデザインパターン
- Factoryパターン
複雑なオブジェクトの生成を隠蔽し、インターフェースを通じてオブジェクトを作成します。
// 製品のインターフェース
class Document {
public:
virtual ~Document() = default;
virtual void open() = 0;
virtual void save() = 0;
};
// 具体的な製品クラス
class PDFDocument : public Document {
public:
void open() override {
std::cout << "Opening PDF document\n";
}
void save() override {
std::cout << "Saving PDF document\n";
}
};
class WordDocument : public Document {
public:
void open() override {
std::cout << "Opening Word document\n";
}
void save() override {
std::cout << "Saving Word document\n";
}
};
// ファクトリークラス
class DocumentFactory {
public:
static std::unique_ptr<Document> createDocument(const std::string& type) {
if (type == "pdf") {
return std::make_unique<PDFDocument>();
} else if (type == "word") {
return std::make_unique<WordDocument>();
}
throw std::runtime_error("Unknown document type");
}
};
- Observerパターン
オブジェクト間の1対多の依存関係を定義し、あるオブジェクトの状態が変化した際に、依存するオブジェクトに自動的に通知します。
class Observer {
public:
virtual ~Observer() = default;
virtual void update(const std::string& message) = 0;
};
class Subject {
private:
std::vector<std::shared_ptr<Observer>> observers_;
public:
void attach(std::shared_ptr<Observer> observer) {
observers_.push_back(observer);
}
void detach(std::shared_ptr<Observer> observer) {
observers_.erase(
std::remove(observers_.begin(), observers_.end(), observer),
observers_.end()
);
}
void notify(const std::string& message) {
for (const auto& observer : observers_) {
observer->update(message);
}
}
};
class ConcreteObserver : public Observer {
private:
std::string name_;
public:
explicit ConcreteObserver(std::string name) : name_(std::move(name)) {}
void update(const std::string& message) override {
std::cout << name_ << " received message: " << message << "\n";
}
};
- Strategyパターン
アルゴリズムをカプセル化し、実行時に切り替え可能にします。
// 戦略インターフェース
class SortStrategy {
public:
virtual ~SortStrategy() = default;
virtual void sort(std::vector<int>& data) = 0;
};
// 具体的な戦略クラス
class QuickSort : public SortStrategy {
public:
void sort(std::vector<int>& data) override {
std::cout << "Performing quick sort\n";
std::sort(data.begin(), data.end());
}
};
class MergeSort : public SortStrategy {
public:
void sort(std::vector<int>& data) override {
std::cout << "Performing merge sort\n";
std::stable_sort(data.begin(), data.end());
}
};
// コンテキストクラス
class Sorter {
private:
std::unique_ptr<SortStrategy> strategy_;
public:
explicit Sorter(std::unique_ptr<SortStrategy> strategy)
: strategy_(std::move(strategy)) {}
void setStrategy(std::unique_ptr<SortStrategy> strategy) {
strategy_ = std::move(strategy);
}
void performSort(std::vector<int>& data) {
strategy_->sort(data);
}
};
パフォーマンスを考慮したパターン選択
- シングルトンパターンの最適化
class Singleton {
private:
Singleton() = default;
public:
// Meyer's Singleton: スレッドセーフで効率的
static Singleton& getInstance() {
static Singleton instance;
return instance;
}
// コピーとムーブを禁止
Singleton(const Singleton&) = delete;
Singleton& operator=(const Singleton&) = delete;
Singleton(Singleton&&) = delete;
Singleton& operator=(Singleton&&) = delete;
void doSomething() {
std::cout << "Singleton is doing something\n";
}
};
- Commandパターンの軽量実装
// 軽量コマンドインターフェース
using Command = std::function<void()>;
class CommandManager {
private:
std::vector<Command> commands_;
std::vector<Command> undoCommands_;
public:
void execute(Command command, Command undoCommand) {
command();
commands_.push_back(std::move(command));
undoCommands_.push_back(std::move(undoCommand));
}
void undo() {
if (!undoCommands_.empty()) {
undoCommands_.back()();
undoCommands_.pop_back();
commands_.pop_back();
}
}
};
// 使用例
class Document {
private:
std::string content_;
public:
void addText(const std::string& text) {
content_ += text;
}
void removeLastCharacters(size_t count) {
if (count <= content_.length()) {
content_.resize(content_.length() - count);
}
}
const std::string& getContent() const { return content_; }
};
// パフォーマンスを考慮したコマンドの実装
void documentExample() {
Document doc;
CommandManager manager;
// テキスト追加コマンド
std::string textToAdd = "Hello";
manager.execute(
[&doc, text = textToAdd]() { doc.addText(text); },
[&doc, length = textToAdd.length()]() {
doc.removeLastCharacters(length);
}
);
}
- パフォーマンス最適化のベストプラクティス
// メモリプール付きファクトリー
template<typename T>
class PooledFactory {
private:
static constexpr size_t POOL_SIZE = 100;
std::array<std::unique_ptr<T>, POOL_SIZE> pool_;
std::vector<size_t> freeIndices_;
public:
PooledFactory() {
for (size_t i = 0; i < POOL_SIZE; ++i) {
freeIndices_.push_back(i);
}
}
T* create() {
if (freeIndices_.empty()) {
return nullptr; // プールが空の場合
}
size_t index = freeIndices_.back();
freeIndices_.pop_back();
if (!pool_[index]) {
pool_[index] = std::make_unique<T>();
}
return pool_[index].get();
}
void release(T* obj) {
auto it = std::find_if(pool_.begin(), pool_.end(),
[obj](const auto& ptr) { return ptr.get() == obj; });
if (it != pool_.end()) {
size_t index = std::distance(pool_.begin(), it);
freeIndices_.push_back(index);
}
}
};
これらのデザインパターンは、適切に実装することで、コードの再利用性、保守性、そしてパフォーマンスを向上させることができます。特に、C++では、テンプレートやスマートポインタを活用することで、型安全性を保ちながら効率的な実装が可能です。パターンの選択時には、メモリ使用量や実行時のオーバーヘッドを考慮し、必要に応じて最適化を行うことが重要です。
オブジェクト指向プログラミングのエラー処理
例外処理を使用した堅実なエラーハンドリング
- カスタム例外クラスの設計
// 基底例外クラス
class ApplicationException : public std::exception {
private:
std::string message_;
public:
explicit ApplicationException(std::string message)
: message_(std::move(message)) {}
const char* what() const noexcept override {
return message_.c_str();
}
};
// 具体的な例外クラス
class DatabaseException : public ApplicationException {
public:
explicit DatabaseException(const std::string& message)
: ApplicationException("Database Error: " + message) {}
};
class ValidationException : public ApplicationException {
public:
explicit ValidationException(const std::string& message)
: ApplicationException("Validation Error: " + message) {}
};
// 例外を使用したデータベース操作の例
class Database {
public:
void connect(const std::string& connectionString) {
if (connectionString.empty()) {
throw ValidationException("Connection string cannot be empty");
}
// 接続処理
if (/* 接続失敗 */) {
throw DatabaseException("Failed to connect to database");
}
}
};
- 階層的な例外処理
class TransactionManager {
private:
Database db_;
std::vector<std::string> logs_;
public:
void executeTransaction(const std::string& query) {
try {
db_.connect("connection_string");
// トランザクション処理
if (query.empty()) {
throw ValidationException("Query cannot be empty");
}
try {
// クエリ実行
logs_.push_back("Query executed successfully");
}
catch (const DatabaseException& e) {
logs_.push_back("Query execution failed");
throw; // 例外を再スロー
}
}
catch (const ValidationException& e) {
std::cerr << "Validation error: " << e.what() << "\n";
// バリデーションエラーの処理
}
catch (const DatabaseException& e) {
std::cerr << "Database error: " << e.what() << "\n";
// データベースエラーの処理
}
catch (...) {
std::cerr << "Unknown error occurred\n";
throw; // 未知の例外は上位層に伝播
}
}
};
RAIIパターンによる安全なリソース管理
- RAIIクラスの実装
class FileHandle {
private:
FILE* file_;
public:
explicit FileHandle(const char* filename, const char* mode)
: file_(std::fopen(filename, mode)) {
if (!file_) {
throw std::runtime_error("Failed to open file");
}
}
~FileHandle() {
if (file_) {
std::fclose(file_);
}
}
// コピー禁止
FileHandle(const FileHandle&) = delete;
FileHandle& operator=(const FileHandle&) = delete;
// ムーブ可能
FileHandle(FileHandle&& other) noexcept
: file_(other.file_) {
other.file_ = nullptr;
}
FileHandle& operator=(FileHandle&& other) noexcept {
if (this != &other) {
if (file_) {
std::fclose(file_);
}
file_ = other.file_;
other.file_ = nullptr;
}
return *this;
}
// ファイル操作メソッド
void write(const std::string& data) {
if (std::fputs(data.c_str(), file_) == EOF) {
throw std::runtime_error("Failed to write to file");
}
}
};
- スコープベースのリソース管理
class MutexLock {
private:
std::mutex& mutex_;
public:
explicit MutexLock(std::mutex& mutex)
: mutex_(mutex) {
mutex_.lock();
}
~MutexLock() {
mutex_.unlock();
}
// コピー禁止
MutexLock(const MutexLock&) = delete;
MutexLock& operator=(const MutexLock&) = delete;
};
class ThreadSafeCounter {
private:
std::mutex mutex_;
int count_ = 0;
public:
void increment() {
MutexLock lock(mutex_); // スコープベースのロック
++count_;
// ロックは自動的に解放される
}
int getValue() const {
MutexLock lock(mutex_);
return count_;
}
};
- 例外安全なリソース管理の実装例
class ResourceManager {
private:
std::vector<std::unique_ptr<Resource>> resources_;
std::mutex mutex_;
public:
void addResource(std::unique_ptr<Resource> resource) {
MutexLock lock(mutex_);
if (!resource) {
throw ValidationException("Resource cannot be null");
}
try {
resource->initialize(); // 例外を投げる可能性がある
resources_.push_back(std::move(resource));
}
catch (const std::exception& e) {
// リソースの初期化に失敗
// unique_ptrとMutexLockにより、リソースは適切に解放される
throw ResourceException(
std::string("Failed to initialize resource: ") + e.what()
);
}
}
void processResources() {
MutexLock lock(mutex_);
for (const auto& resource : resources_) {
try {
resource->process();
}
catch (const std::exception& e) {
// エラーをログに記録するが、他のリソースの処理は継続
std::cerr << "Error processing resource: "
<< e.what() << "\n";
}
}
}
};
- トランザクション的なリソース管理
template<typename T>
class TransactionalResource {
private:
T currentState_;
T previousState_;
bool modified_ = false;
public:
explicit TransactionalResource(T initial)
: currentState_(std::move(initial))
, previousState_(currentState_) {}
void modify(const std::function<void(T&)>& operation) {
previousState_ = currentState_; // 状態をバックアップ
modified_ = true;
try {
operation(currentState_); // 変更を適用
}
catch (...) {
rollback(); // エラー時は元の状態に戻す
throw;
}
}
void commit() {
if (modified_) {
previousState_ = currentState_;
modified_ = false;
}
}
void rollback() {
if (modified_) {
currentState_ = previousState_;
modified_ = false;
}
}
const T& getState() const {
return currentState_;
}
};
これらの実装例は、C++におけるエラー処理とリソース管理の基本的なパターンを示しています。RAIIパターンを活用することで、例外が発生した場合でもリソースの確実な解放を保証し、メモリリークなどの問題を防ぐことができます。また、適切な例外処理を実装することで、エラーの発生を適切に検知し、システムの堅牢性を向上させることができます。
オブジェクト指向プログラミングのベストプラクティス
コードの保守性を高めるクラス設計の原則
- 単一責任の原則（SRP）の実装
// 悪い例：複数の責任を持つクラス
class UserManager {
public:
void createUser(const std::string& name) { /* ... */ }
void saveToDatabase() { /* ... */ }
void sendEmail(const std::string& message) { /* ... */ }
void generateReport() { /* ... */ }
};
// 良い例：責任の分離
class User {
private:
std::string name_;
std::string email_;
public:
User(std::string name, std::string email)
: name_(std::move(name))
, email_(std::move(email)) {}
const std::string& getName() const { return name_; }
const std::string& getEmail() const { return email_; }
};
class UserRepository {
public:
void save(const User& user) { /* データベース操作 */ }
User load(const std::string& userId) { /* ... */ }
};
class EmailService {
public:
void sendEmail(const std::string& to, const std::string& message) {
/* メール送信処理 */
}
};
class ReportGenerator {
public:
void generateUserReport(const User& user) { /* ... */ }
};
- 依存性注入の活用
class ILogger {
public:
virtual ~ILogger() = default;
virtual void log(const std::string& message) = 0;
};
class ConsoleLogger : public ILogger {
public:
void log(const std::string& message) override {
std::cout << "Log: " << message << std::endl;
}
};
class FileLogger : public ILogger {
public:
void log(const std::string& message) override {
// ファイルへのログ出力
}
};
class UserService {
private:
std::shared_ptr<ILogger> logger_;
std::shared_ptr<UserRepository> repository_;
public:
UserService(std::shared_ptr<ILogger> logger,
std::shared_ptr<UserRepository> repository)
: logger_(std::move(logger))
, repository_(std::move(repository)) {}
void createUser(const std::string& name, const std::string& email) {
logger_->log("Creating new user: " + name);
User user(name, email);
repository_->save(user);
}
};
- インターフェース分離の原則
// 大きすぎるインターフェース（避けるべき）
class IDevice {
public:
virtual void print() = 0;
virtual void scan() = 0;
virtual void fax() = 0;
virtual void copy() = 0;
};
// 分離されたインターフェース（推奨）
class IPrinter {
public:
virtual ~IPrinter() = default;
virtual void print() = 0;
};
class IScanner {
public:
virtual ~IScanner() = default;
virtual void scan() = 0;
};
class IFax {
public:
virtual ~IFax() = default;
virtual void fax() = 0;
};
// 必要なインターフェースのみを実装
class SimplePrinter : public IPrinter {
public:
void print() override { /* 印刷処理 */ }
};
class MultiFunctionPrinter : public IPrinter, public IScanner, public IFax {
public:
void print() override { /* 印刷処理 */ }
void scan() override { /* スキャン処理 */ }
void fax() override { /* FAX処理 */ }
};
テスタビリティを考慮したインターフェース設計
- モックオブジェクトの作成とテスト
// テスト可能なインターフェース設計
class IPaymentGateway {
public:
virtual ~IPaymentGateway() = default;
virtual bool processPayment(double amount) = 0;
};
class PaymentProcessor {
private:
std::shared_ptr<IPaymentGateway> gateway_;
public:
explicit PaymentProcessor(std::shared_ptr<IPaymentGateway> gateway)
: gateway_(std::move(gateway)) {}
bool makePayment(double amount) {
return gateway_->processPayment(amount);
}
};
// モックオブジェクト
class MockPaymentGateway : public IPaymentGateway {
public:
bool processPayment(double amount) override {
lastAmount_ = amount;
return shouldSucceed_;
}
void setShouldSucceed(bool value) { shouldSucceed_ = value; }
double getLastAmount() const { return lastAmount_; }
private:
bool shouldSucceed_ = true;
double lastAmount_ = 0.0;
};
// テストコード
void testPaymentProcessor() {
auto mockGateway = std::make_shared<MockPaymentGateway>();
PaymentProcessor processor(mockGateway);
// 成功ケースのテスト
assert(processor.makePayment(100.0));
assert(mockGateway->getLastAmount() == 100.0);
// 失敗ケースのテスト
mockGateway->setShouldSucceed(false);
assert(!processor.makePayment(50.0));
assert(mockGateway->getLastAmount() == 50.0);
}
- 依存関係の分離とテスト容易性
// 設定の抽象化
class IConfiguration {
public:
virtual ~IConfiguration() = default;
virtual std::string getDatabaseUrl() const = 0;
virtual int getTimeout() const = 0;
};
class DatabaseConnection {
private:
std::shared_ptr<IConfiguration> config_;
std::shared_ptr<ILogger> logger_;
public:
DatabaseConnection(std::shared_ptr<IConfiguration> config,
std::shared_ptr<ILogger> logger)
: config_(std::move(config))
, logger_(std::move(logger)) {}
bool connect() {
auto url = config_->getDatabaseUrl();
auto timeout = config_->getTimeout();
logger_->log("Connecting to: " + url);
return true; // 実際の接続処理
}
};
// テスト用の設定
class MockConfiguration : public IConfiguration {
public:
std::string getDatabaseUrl() const override {
return "mock://database";
}
int getTimeout() const override {
return 100;
}
};
// テスト用のロガー
class MockLogger : public ILogger {
public:
void log(const std::string& message) override {
messages_.push_back(message);
}
const std::vector<std::string>& getMessages() const {
return messages_;
}
private:
std::vector<std::string> messages_;
};
- テスト駆動開発（TDD）のサポート
class Calculator {
public:
virtual ~Calculator() = default;
virtual int add(int a, int b) {
return a + b;
}
virtual int subtract(int a, int b) {
return a - b;
}
virtual int multiply(int a, int b) {
return a * b;
}
virtual double divide(int a, int b) {
if (b == 0) {
throw std::invalid_argument("Division by zero");
}
return static_cast<double>(a) / b;
}
};
// テストケース
void testCalculator() {
Calculator calc;
// 加算のテスト
assert(calc.add(2, 3) == 5);
assert(calc.add(-1, 1) == 0);
// 減算のテスト
assert(calc.subtract(5, 3) == 2);
assert(calc.subtract(1, 1) == 0);
// 乗算のテスト
assert(calc.multiply(2, 3) == 6);
assert(calc.multiply(-2, 3) == -6);
// 除算のテスト
assert(calc.divide(6, 2) == 3.0);
assert(calc.divide(5, 2) == 2.5);
// 例外のテスト
try {
calc.divide(1, 0);
assert(false); // この行に到達してはいけない
} catch (const std::invalid_argument&) {
// 期待通りの例外が発生
}
}
これらの実装例は、C++でのオブジェクト指向プログラミングのベストプラクティスを示しています。単一責任の原則、依存性注入、インターフェース分離などの設計原則を適切に適用することで、保守性が高く、テストが容易なコードを作成することができます。また、モックオブジェクトやテスト駆動開発の手法を活用することで、信頼性の高いソフトウェアの開発が可能になります。