[C++] クラスの使い方をわかりやすく解説

#include <iostream>
using namespace std;
class MyClass {
public:
    int myVariable; // メンバ変数
    void myFunction() { // メンバ関数
        cout << "Hello from MyClass!" << endl;
    }
};
int main() {
    MyClass obj; // クラスのインスタンス化
    obj.myVariable = 10; // メンバ変数へのアクセス
    obj.myFunction(); // メンバ関数の呼び出し
    return 0;
}

Hello from MyClass!

#include <iostream>
using namespace std;
class ClassName { // クラス名
public: // アクセス修飾子
    // メンバ変数
    int variable;
    // メンバ関数
    void function() {
        cout << "メンバ関数が呼ばれました。" << endl;
    }
};

#include <iostream>
using namespace std;
class Person {
public:
    string name; // メンバ変数
    int age;     // メンバ変数
    void introduce() { // メンバ関数
        cout << "私の名前は " << name << " で、年齢は " << age << " 歳です。" << endl;
    }
};
int main() {
    Person person; // クラスのインスタンス化
    person.name = "太郎"; // メンバ変数へのアクセス
    person.age = 25;      // メンバ変数へのアクセス
    person.introduce();   // メンバ関数の呼び出し
    return 0;
}

私の名前は 太郎 で、年齢は 25 歳です。

#include <iostream>
using namespace std;
class Sample {
public:
    Sample() { // コンストラクタ
        cout << "オブジェクトが生成されました。" << endl;
    }
    ~Sample() { // デストラクタ
        cout << "オブジェクトが破棄されました。" << endl;
    }
};
int main() {
    Sample obj; // オブジェクトの生成
    return 0;   // オブジェクトの破棄
}

オブジェクトが生成されました。
オブジェクトが破棄されました。

#include <iostream>
using namespace std;
class MyClass {
public:
    void display() {
        cout << "MyClassのインスタンスです。" << endl;
    }
};
int main() {
    MyClass obj; // クラスのインスタンス化
    obj.display(); // メンバ関数の呼び出し
    return 0;
}

MyClassのインスタンスです。

#include <iostream>
using namespace std;
class Calculator {
public:
    // メンバ関数の定義
    int add(int a, int b) {
        return a + b; // 足し算を行う
    }
};
int main() {
    Calculator calc; // クラスのインスタンス化
    int result = calc.add(5, 3); // メンバ関数の呼び出し
    cout << "5 + 3 = " << result << endl; // 結果の表示
    return 0;
}

5 + 3 = 8

#include <iostream>
using namespace std;
class Counter {
private:
    int count;
public:
    Counter() : count(0) {} // コンストラクタ
    void increment() {
        count++; // カウントを増やす
    }
    // constメンバ関数
    int getCount() const {
        return count; // カウントを返す
    }
};
int main() {
    Counter counter; // クラスのインスタンス化
    counter.increment(); // メンバ関数の呼び出し
    cout << "カウント: " << counter.getCount() << endl; // constメンバ関数の呼び出し
    return 0;
}

カウント: 1

#include <iostream>
using namespace std;
class Display {
public:
    // 整数を表示するメンバ関数
    void show(int value) {
        cout << "整数: " << value << endl;
    }
    // 文字列を表示するメンバ関数
    void show(string value) {
        cout << "文字列: " << value << endl;
    }
};
int main() {
    Display display; // クラスのインスタンス化
    display.show(10); // 整数のメンバ関数の呼び出し
    display.show("こんにちは"); // 文字列のメンバ関数の呼び出し
    return 0;
}

整数: 10
文字列: こんにちは

#include <iostream>
using namespace std;
class Square {
public:
    // インラインメンバ関数
    int area(int side) {
        return side * side; // 面積を計算
    }
};
int main() {
    Square square; // クラスのインスタンス化
    int side = 4;
    cout << "一辺が " << side << " の正方形の面積: " << square.area(side) << endl; // インラインメンバ関数の呼び出し
    return 0;
}

一辺が 4 の正方形の面積: 16

#include <iostream>
using namespace std;
class Point {
public:
    int x, y; // メンバ変数
    // コンストラクタ
    Point(int xCoord, int yCoord) {
        x = xCoord; // x座標の初期化
        y = yCoord; // y座標の初期化
    }
    void display() {
        cout << "Point(" << x << ", " << y << ")" << endl; // 座標の表示
    }
};
int main() {
    Point p(10, 20); // コンストラクタの呼び出し
    p.display(); // メンバ関数の呼び出し
    return 0;
}

Point(10, 20)

#include <iostream>
using namespace std;
class Rectangle {
public:
    int width, height;
    // デフォルトコンストラクタ
    Rectangle() {
        width = 1; // デフォルト値
        height = 1; // デフォルト値
    }
    // 引数付きコンストラクタ
    Rectangle(int w, int h) {
        width = w; // 幅の初期化
        height = h; // 高さの初期化
    }
    int area() {
        return width * height; // 面積の計算
    }
};
int main() {
    Rectangle rect1; // デフォルトコンストラクタの呼び出し
    Rectangle rect2(5, 10); // 引数付きコンストラクタの呼び出し
    cout << "rect1の面積: " << rect1.area() << endl; // 面積の表示
    cout << "rect2の面積: " << rect2.area() << endl; // 面積の表示
    return 0;
}

rect1の面積: 1
rect2の面積: 50

#include <iostream>
using namespace std;
class Resource {
public:
    Resource() {
        cout << "リソースが確保されました。" << endl; // リソースの確保
    }
    ~Resource() {
        cout << "リソースが解放されました。" << endl; // リソースの解放
    }
};
int main() {
    Resource res; // コンストラクタの呼び出し
    // ここでリソースを使用する
    return 0; // デストラクタの呼び出し
}

リソースが確保されました。
リソースが解放されました。

#include <iostream>
using namespace std;
class Circle {
public:
    double radius;
    // コンストラクタの初期化リスト
    Circle(double r) : radius(r) {
        // radiusは初期化リストで初期化される
    }
    double area() {
        return 3.14 * radius * radius; // 面積の計算
    }
};
int main() {
    Circle circle(5.0); // コンストラクタの呼び出し
    cout << "円の面積: " << circle.area() << endl; // 面積の表示
    return 0;
}

円の面積: 78.5

#include <iostream>
using namespace std;
class Base {
public:
    int publicVar; // publicメンバ
protected:
    int protectedVar; // protectedメンバ
private:
    int privateVar; // privateメンバ
public:
    Base() : publicVar(1), protectedVar(2), privateVar(3) {}
    void display() {
        cout << "publicVar: " << publicVar << endl;
        cout << "protectedVar: " << protectedVar << endl;
        cout << "privateVar: " << privateVar << endl; // 同じクラス内からアクセス可能
    }
};
class Derived : public Base {
public:
    void show() {
        cout << "Derivedからのアクセス:" << endl;
        cout << "publicVar: " << publicVar << endl; // publicメンバにはアクセス可能
        cout << "protectedVar: " << protectedVar << endl; // protectedメンバにはアクセス可能
        // cout << "privateVar: " << privateVar << endl; // privateメンバにはアクセス不可
    }
};
int main() {
    Base base;
    base.display(); // publicとprivateメンバの表示
    Derived derived;
    derived.show(); // Derivedクラスからの表示
    return 0;
}

publicVar: 1
protectedVar: 2
privateVar: 3
Derivedからのアクセス:
publicVar: 1
protectedVar: 2

#include <iostream>
using namespace std;
class Box {
   private:
    int width;

   public:
    Box(int w) : width(w) {}
    // フレンド関数の宣言
    friend void printWidth(Box box);
    // BoxManagerをフレンドクラスとして宣言
    friend class BoxManager;
};
// フレンド関数の定義
void printWidth(Box box) {
    cout << "Boxの幅: " << box.width << endl; // privateメンバにアクセス
}
class Container {
   private:
    Box box;

   public:
    Container(int w) : box(w) {}
    // フレンドクラスの宣言
    friend class BoxManager;
};
class BoxManager {
   public:
    void showBoxWidth(Container container) {
        cout << "Container内のBoxの幅: " << container.box.width
             << endl; // privateメンバにアクセス
    }
};
int main() {
    Box box(10);
    printWidth(box); // フレンド関数の呼び出し
    Container container(20);
    BoxManager manager;
    manager.showBoxWidth(container); // フレンドクラスのメンバ関数の呼び出し
    return 0;
}

Boxの幅: 10
Container内のBoxの幅: 20

#include <iostream>
using namespace std;
class Animal {
public:
    void speak() {
        cout << "動物の声" << endl; // 基底クラスのメソッド
    }
};
class Dog : public Animal { // DogクラスがAnimalクラスを継承
public:
    void bark() {
        cout << "ワンワン" << endl; // Dogクラスのメソッド
    }
};
int main() {
    Dog dog; // Dogクラスのインスタンス化
    dog.speak(); // 基底クラスのメソッドの呼び出し
    dog.bark();  // Dogクラスのメソッドの呼び出し
    return 0;
}

動物の声
ワンワン

#include <iostream>
using namespace std;
class Vehicle {
public:
    void start() {
        cout << "車がスタートしました。" << endl; // 基底クラスのメソッド
    }
};
class Car : public Vehicle { // CarクラスがVehicleクラスを継承
public:
    void honk() {
        cout << "ビービー" << endl; // Carクラスのメソッド
    }
};
int main() {
    Car car; // Carクラスのインスタンス化
    car.start(); // 基底クラスのメソッドの呼び出し
    car.honk();  // Carクラスのメソッドの呼び出し
    return 0;
}

車がスタートしました。
ビービー

#include <iostream>
using namespace std;
class Base {
public:
    int publicVar;
protected:
    int protectedVar;
private:
    int privateVar;
};
class PublicDerived : public Base {
public:
    void show() {
        cout << "PublicDerived: " << publicVar << endl; // publicメンバにアクセス可能
        cout << "PublicDerived: " << protectedVar << endl; // protectedメンバにアクセス可能
        // cout << "PublicDerived: " << privateVar << endl; // privateメンバにはアクセス不可
    }
};
class PrivateDerived : private Base {
public:
    void show() {
        cout << "PrivateDerived: " << publicVar << endl; // publicメンバにアクセス可能
        cout << "PrivateDerived: " << protectedVar << endl; // protectedメンバにアクセス可能
        // cout << "PrivateDerived: " << privateVar << endl; // privateメンバにはアクセス不可
    }
};
int main() {
    PublicDerived pubDerived;
    pubDerived.publicVar = 10; // publicメンバへのアクセス
    pubDerived.show();
    PrivateDerived privDerived;
    // privDerived.publicVar = 20; // private継承のためアクセス不可
    privDerived.show();
    return 0;
}

PublicDerived: 10
PrivateDerived: 0

#include <iostream>
using namespace std;
class Shape {
public:
    virtual void draw() { // 仮想関数
        cout << "形状を描画します。" << endl;
    }
};
class Circle : public Shape {
public:
    void draw() override { // オーバーライド
        cout << "円を描画します。" << endl;
    }
};
class Square : public Shape {
public:
    void draw() override { // オーバーライド
        cout << "正方形を描画します。" << endl;
    }
};
void render(Shape* shape) {
    shape->draw(); // 多態性を利用して呼び出し
}
int main() {
    Circle circle;
    Square square;
    render(&circle); // Circleオブジェクトを渡す
    render(&square); // Squareオブジェクトを渡す
    return 0;
}

円を描画します。
正方形を描画します。

#include <iostream>
using namespace std;
class Base {
public:
    virtual void show() { // オーバーライドされる仮想関数
        cout << "Baseクラスのshow()" << endl;
    }
    void display(int a) { // オーバーロードされる関数
        cout << "Baseクラスのdisplay(int): " << a << endl;
    }
};
class Derived : public Base {
public:
    void show() override { // オーバーライド
        cout << "Derivedクラスのshow()" << endl;
    }
    void display(double b) { // オーバーロード
        cout << "Derivedクラスのdisplay(double): " << b << endl;
    }
};
int main() {
    Base* basePtr;
    Derived derived;
    basePtr = &derived;
    basePtr->show(); // オーバーライドされたメソッドの呼び出し
    basePtr->display(10); // Baseクラスのdisplay(int)が呼び出される
    derived.display(3.14); // Derivedクラスのdisplay(double)が呼び出される
    return 0;
}

Derivedクラスのshow()
Baseクラスのdisplay(int): 10
Derivedクラスのdisplay(double): 3.14

#include <iostream>
using namespace std;
class Shape {
public:
    virtual void draw() = 0; // 純粋仮想関数
};
class Circle : public Shape {
public:
    void draw() override { // オーバーライド
        cout << "円を描画します。" << endl;
    }
};
class Square : public Shape {
public:
    void draw() override { // オーバーライド
        cout << "正方形を描画します。" << endl;
    }
};
int main() {
    Shape* shape1 = new Circle(); // Circleオブジェクトの生成
    Shape* shape2 = new Square(); // Squareオブジェクトの生成
    shape1->draw(); // 円を描画
    shape2->draw(); // 正方形を描画
    delete shape1; // メモリの解放
    delete shape2; // メモリの解放
    return 0;
}

円を描画します。
正方形を描画します。

#include <iostream>
using namespace std;
class IAnimal {
public:
    virtual void makeSound() = 0; // 純粋仮想関数
};
class Dog : public IAnimal {
public:
    void makeSound() override {
        cout << "ワンワン" << endl; // 犬の鳴き声
    }
};
class Cat : public IAnimal {
public:
    void makeSound() override {
        cout << "ニャー" << endl; // 猫の鳴き声
    }
};
int main() {
    IAnimal* animal1 = new Dog(); // Dogオブジェクトの生成
    IAnimal* animal2 = new Cat(); // Catオブジェクトの生成
    animal1->makeSound(); // 犬の鳴き声
    animal2->makeSound(); // 猫の鳴き声
    delete animal1; // メモリの解放
    delete animal2; // メモリの解放
    return 0;
}

ワンワン
ニャー

#include <iostream>
using namespace std;
template <typename T>
class Box {
private:
    T value; // テンプレート型のメンバ変数
public:
    Box(T val) : value(val) {} // コンストラクタ
    T getValue() {
        return value; // 値を返す
    }
};
int main() {
    Box<int> intBox(123); // int型のBox
    Box<string> strBox("こんにちは"); // string型のBox
    cout << "intBoxの値: " << intBox.getValue() << endl; // int型の値
    cout << "strBoxの値: " << strBox.getValue() << endl; // string型の値
    return 0;
}

intBoxの値: 123
strBoxの値: こんにちは

#include <iostream>
using namespace std;
namespace Geometry {
    class Circle {
    public:
        void draw() {
            cout << "Geometryの円を描画します。" << endl;
        }
    };
}
namespace Graphics {
    class Circle {
    public:
        void draw() {
            cout << "Graphicsの円を描画します。" << endl;
        }
    };
}
int main() {
    Geometry::Circle geoCircle; // Geometry名前空間のCircle
    Graphics::Circle graphCircle; // Graphics名前空間のCircle
    geoCircle.draw(); // Geometryの円を描画
    graphCircle.draw(); // Graphicsの円を描画
    return 0;
}

Geometryの円を描画します。
Graphicsの円を描画します。

#include <iostream>
#include <memory> // スマートポインタのヘッダ
using namespace std;
class Resource {
public:
    Resource() {
        cout << "リソースが確保されました。" << endl;
    }
    ~Resource() {
        cout << "リソースが解放されました。" << endl;
    }
};
int main() {
    {
        unique_ptr<Resource> res1(new Resource()); // unique_ptrの使用
        // res1はスコープを抜けると自動的に解放される
    }
    {
        shared_ptr<Resource> res2(new Resource()); // shared_ptrの使用
        {
            shared_ptr<Resource> res3 = res2; // 参照カウントが増える
            cout << "リソースはまだ解放されません。" << endl;
        } // res3がスコープを抜けると参照カウントが減る
        cout << "res2がまだ存在します。" << endl;
    } // res2がスコープを抜けると自動的に解放される
    return 0;
}

リソースが確保されました。
リソースが解放されました。
リソースが確保されました。
リソースはまだ解放されません。
res2がまだ存在します。
リソースが解放されました。

#include <iostream>
using namespace std;
class MyClass {
public:
    MyClass() {
        cout << "MyClassのインスタンスが生成されました。" << endl;
    }
    ~MyClass() {
        cout << "MyClassのインスタンスが破棄されました。" << endl;
    }
};
int main() {
    MyClass* obj = new MyClass(); // 動的メモリの確保
    delete obj; // メモリの解放
    return 0;
}

MyClassのインスタンスが生成されました。
MyClassのインスタンスが破棄されました。

#include <iostream>
using namespace std;
class MyClass {
private:
    int* data;
public:
    MyClass(int value) {
        data = new int(value); // 動的メモリの確保
    }
    // コピーコンストラクタ
    MyClass(const MyClass& other) {
        data = new int(*other.data); // 深いコピー
    }
    // 代入演算子
    MyClass& operator=(const MyClass& other) {
        if (this != &other) { // 自己代入のチェック
            delete data; // 既存のメモリを解放
            data = new int(*other.data); // 深いコピー
        }
        return *this;
    }
    ~MyClass() {
        delete data; // メモリの解放
    }
    void display() {
        cout << "値: " << *data << endl;
    }
};
int main() {
    MyClass obj1(10); // obj1の生成
    MyClass obj2 = obj1; // コピーコンストラクタの呼び出し
    obj2.display(); // obj2の値を表示
    MyClass obj3(20); // obj3の生成
    obj3 = obj1; // 代入演算子の呼び出し
    obj3.display(); // obj3の値を表示
    return 0;
}

値: 10
値: 10

#include <iostream>
using namespace std;
class MyClass {
private:
    int* data;
public:
    MyClass(int value) {
        data = new int(value); // 動的メモリの確保
    }
    // ムーブコンストラクタ
    MyClass(MyClass&& other) noexcept {
        data = other.data; // 所有権の移動
        other.data = nullptr; // 元のオブジェクトのポインタを無効化
    }
    // ムーブ代入演算子
    MyClass& operator=(MyClass&& other) noexcept {
        if (this != &other) {
            delete data; // 既存のメモリを解放
            data = other.data; // 所有権の移動
            other.data = nullptr; // 元のオブジェクトのポインタを無効化
        }
        return *this;
    }
    ~MyClass() {
        delete data; // メモリの解放
    }
    void display() {
        if (data) {
            cout << "値: " << *data << endl;
        } else {
            cout << "データは無効です。" << endl;
        }
    }
};
int main() {
    MyClass obj1(10); // obj1の生成
    MyClass obj2 = std::move(obj1); // ムーブコンストラクタの呼び出し
    obj2.display(); // obj2の値を表示
    obj1.display(); // obj1の値を表示(無効)
    MyClass obj3(20); // obj3の生成
    obj3 = std::move(obj2); // ムーブ代入演算子の呼び出し
    obj3.display(); // obj3の値を表示
    obj2.display(); // obj2の値を表示(無効)
    return 0;
}

値: 10
データは無効です。
値: 10
データは無効です。

#include <iostream>
#include <memory> // スマートポインタのヘッダ
using namespace std;
class Resource {
public:
    Resource() {
        cout << "リソースが確保されました。" << endl;
    }
    ~Resource() {
        cout << "リソースが解放されました。" << endl;
    }
};
int main() {
    {
        unique_ptr<Resource> res(new Resource()); // RAIIを利用したリソース管理
        // resはスコープを抜けると自動的に解放される
    }
    cout << "スコープを抜けました。" << endl;
    return 0;
}

リソースが確保されました。
スコープを抜けました。
リソースが解放されました。