[C++] クラスのメンバ関数を呼び出す方法(private/protected/public)

#include <iostream>
using namespace std;
class MyClass {
public:
    void displayMessage() {
        cout << "こんにちは、C++の世界！" << endl;
    }
};
int main() {
    MyClass obj; // インスタンスの生成
    obj.displayMessage(); // publicメンバ関数の呼び出し
    return 0;
}

こんにちは、C++の世界！

#include <iostream>
using namespace std;
class MyClass {
public:
    void displayMessage() {
        cout << "ポインタを使った呼び出し！" << endl;
    }
};
int main() {
    MyClass obj; // インスタンスの生成
    MyClass* ptr = &obj; // ポインタの生成
    ptr->displayMessage(); // ポインタを使ったpublicメンバ関数の呼び出し
    return 0;
}

ポインタを使った呼び出し！

#include <iostream>
using namespace std;
class MyClass {
public:
    MyClass() { // コンストラクタ
        displayMessage(); // publicメンバ関数の呼び出し
    }
    void displayMessage() {
        cout << "コンストラクタからの呼び出し！" << endl;
    }
};
int main() {
    MyClass obj; // インスタンスの生成
    return 0;
}

コンストラクタからの呼び出し！

#include <iostream>
using namespace std;
class MyClass {
private:
    void privateFunction() { // privateメンバ関数
        cout << "これはprivateメンバ関数です。" << endl;
    }
public:
    void publicFunction() { // publicメンバ関数
        privateFunction(); // privateメンバ関数の呼び出し
    }
};
int main() {
    MyClass obj; // インスタンスの生成
    obj.publicFunction(); // publicメンバ関数を通じてprivateメンバ関数を呼び出す
    return 0;
}

これはprivateメンバ関数です。

#include <iostream>
using namespace std;
class MyClass {
private:
    void privateFunction() { // privateメンバ関数
        cout << "フレンド関数から呼び出されたprivateメンバ関数です。" << endl;
    }
    friend void friendFunction(MyClass& obj); // フレンド関数の宣言
};
void friendFunction(MyClass& obj) { // フレンド関数
    obj.privateFunction(); // privateメンバ関数の呼び出し
}
int main() {
    MyClass obj; // インスタンスの生成
    friendFunction(obj); // フレンド関数を通じてprivateメンバ関数を呼び出す
    return 0;
}

フレンド関数から呼び出されたprivateメンバ関数です。

#include <iostream>
using namespace std;
class MyClass {
private:
    int value; // privateメンバ
    void privateFunction() { // privateメンバ関数
        cout << "privateFunctionが呼び出されました。値: " << value << endl;
    }
public:
    void setValue(int v) { // setter
        value = v;
        privateFunction(); // setter内でprivateメンバ関数を呼び出す
    }
    int getValue() { // getter
        return value;
    }
};
int main() {
    MyClass obj; // インスタンスの生成
    obj.setValue(10); // setterを通じて値を設定
    cout << "取得した値: " << obj.getValue() << endl; // getterを通じて値を取得
    return 0;
}

privateFunctionが呼び出されました。値: 10
取得した値: 10

#include <iostream>
using namespace std;
class BaseClass {
protected:
    void protectedFunction() { // protectedメンバ関数
        cout << "BaseClassのprotectedメンバ関数が呼び出されました。" << endl;
    }
};
class DerivedClass : public BaseClass {
public:
    void callProtectedFunction() { // 派生クラスのメンバ関数
        protectedFunction(); // protectedメンバ関数の呼び出し
    }
};
int main() {
    DerivedClass obj; // 派生クラスのインスタンスの生成
    obj.callProtectedFunction(); // 派生クラスのメンバ関数を通じてprotectedメンバ関数を呼び出す
    return 0;
}

BaseClassのprotectedメンバ関数が呼び出されました。

#include <iostream>
using namespace std;
class MyClass {
private:
    int value;
public:
    MyClass(int v) : value(v) {} // コンストラクタ
    // constメンバ関数
    int getValue() const { 
        return value; 
    }
};
int main() {
    const MyClass obj(10); // constオブジェクトの生成
    cout << "取得した値: " << obj.getValue() << endl; // constメンバ関数の呼び出し
    return 0;
}

取得した値: 10

#include <iostream>
using namespace std;
class MyClass {
public:
    static void staticFunction() { // staticメンバ関数
        cout << "これはstaticメンバ関数です。" << endl;
    }
};
int main() {
    MyClass::staticFunction(); // staticメンバ関数の呼び出し
    return 0;
}

これはstaticメンバ関数です。

#include <iostream>
using namespace std;
class BaseClass {
public:
    virtual void display() { // 仮想関数
        cout << "BaseClassのdisplay関数です。" << endl;
    }
};
class DerivedClass : public BaseClass {
public:
    void display() override { // オーバーライド
        cout << "DerivedClassのdisplay関数です。" << endl;
    }
};
int main() {
    BaseClass* ptr = new DerivedClass(); // 基底クラスのポインタ
    ptr->display(); // 仮想関数の呼び出し
    delete ptr; // メモリの解放
    return 0;
}

DerivedClassのdisplay関数です。

#include <iostream>
using namespace std;
class MyClass {
public:
    void display(int value) { // 整数引数のオーバーロード
        cout << "整数: " << value << endl;
    }
    void display(double value) { // 浮動小数点引数のオーバーロード
        cout << "浮動小数点: " << value << endl;
    }
};
int main() {
    MyClass obj; // インスタンスの生成
    obj.display(10); // 整数引数の呼び出し
    obj.display(3.14); // 浮動小数点引数の呼び出し
    return 0;
}

整数: 10
浮動小数点: 3.14

#include <iostream>
using namespace std;
class MyClass {
public:
    void display() { // メンバ関数
        cout << "メンバ関数が呼び出されました。" << endl;
    }
};
int main() {
    MyClass obj; // インスタンスの生成
    // メンバ関数ポインタの宣言
    void (MyClass::*funcPtr)() = &MyClass::display; // メンバ関数ポインタの初期化
    // メンバ関数ポインタを使ってメンバ関数を呼び出す
    (obj.*funcPtr)(); // インスタンスを通じて呼び出し
    return 0;
}

メンバ関数が呼び出されました。

#include <iostream>
using namespace std;
class MyClass {
public:
    void displayA() {
        cout << "displayAが呼び出されました。" << endl;
    }
    void displayB() {
        cout << "displayBが呼び出されました。" << endl;
    }
};
int main() {
    MyClass obj; // インスタンスの生成
    // メンバ関数ポインタの配列
    void (MyClass::*funcPtrs[])() = { &MyClass::displayA, &MyClass::displayB };
    // 動的にメンバ関数を呼び出す
    for (int i = 0; i < 2; ++i) {
        (obj.*funcPtrs[i])(); // 各メンバ関数を呼び出す
    }
    return 0;
}

displayAが呼び出されました。
displayBが呼び出されました。

#include <iostream>
using namespace std;
template <typename T>
void callMemberFunction(T& obj, void (T::*funcPtr)()) {
    (obj.*funcPtr)(); // メンバ関数ポインタを使って呼び出す
}
class MyClass {
public:
    void display() {
        cout << "MyClassのdisplay関数が呼び出されました。" << endl;
    }
};
class AnotherClass {
public:
    void show() {
        cout << "AnotherClassのshow関数が呼び出されました。" << endl;
    }
};
int main() {
    MyClass obj1; // MyClassのインスタンス
    AnotherClass obj2; // AnotherClassのインスタンス
    // MyClassのメンバ関数ポインタ
    void (MyClass::*funcPtr1)() = &MyClass::display;
    callMemberFunction(obj1, funcPtr1); // MyClassのメンバ関数を呼び出す
    // AnotherClassのメンバ関数ポインタ
    void (AnotherClass::*funcPtr2)() = &AnotherClass::show;
    callMemberFunction(obj2, funcPtr2); // AnotherClassのメンバ関数を呼び出す
    return 0;
}

MyClassのdisplay関数が呼び出されました。
AnotherClassのshow関数が呼び出されました。

#include <iostream>
using namespace std;
class BaseClass {
public:
    void display() { // 基底クラスのメンバ関数
        cout << "BaseClassのdisplay関数が呼び出されました。" << endl;
    }
};
class DerivedClass : public BaseClass {
public:
    void callBaseFunction() {
        BaseClass::display(); // 基底クラスのメンバ関数を呼び出す
    }
};
int main() {
    DerivedClass obj; // 派生クラスのインスタンス
    obj.callBaseFunction(); // 基底クラスのメンバ関数を呼び出す
    return 0;
}

BaseClassのdisplay関数が呼び出されました。

#include <iostream>
using namespace std;
class BaseClass {
public:
    virtual void display() { // 仮想関数
        cout << "BaseClassのdisplay関数が呼び出されました。" << endl;
    }
};
class DerivedClass : public BaseClass {
public:
    void display() override { // オーバーライド
        cout << "DerivedClassのdisplay関数が呼び出されました。" << endl;
    }
};
int main() {
    BaseClass* ptr = new DerivedClass(); // 基底クラスのポインタ
    ptr->display(); // オーバーライドされたメンバ関数を呼び出す
    delete ptr; // メモリの解放
    return 0;
}

DerivedClassのdisplay関数が呼び出されました。

#include <iostream>
using namespace std;
class BaseClass {
public:
    virtual void sound() { // 仮想関数
        cout << "BaseClassの音です。" << endl;
    }
};
class Dog : public BaseClass {
public:
    void sound() override { // オーバーライド
        cout << "犬の鳴き声: ワン！" << endl;
    }
};
class Cat : public BaseClass {
public:
    void sound() override { // オーバーライド
        cout << "猫の鳴き声: ニャー！" << endl;
    }
};
int main() {
    BaseClass* animals[2]; // 基底クラスのポインタ配列
    animals[0] = new Dog(); // Dogオブジェクト
    animals[1] = new Cat(); // Catオブジェクト
    for (int i = 0; i < 2; ++i) {
        animals[i]->sound(); // ポリモーフィズムを利用して呼び出し
    }
    // メモリの解放
    delete animals[0];
    delete animals[1];
    return 0;
}

犬の鳴き声: ワン！
猫の鳴き声: ニャー！

#include <iostream>
using namespace std;
class BaseClass {
private:
    void privateFunction() { // privateメンバ関数
        cout << "BaseClassのprivateFunctionが呼び出されました。" << endl;
    }
protected:
    void protectedFunction() { // protectedメンバ関数
        cout << "BaseClassのprotectedFunctionが呼び出されました。" << endl;
    }
public:
    void callProtectedFunction() { // publicメンバ関数
        protectedFunction(); // protectedメンバ関数を呼び出す
    }
};
class DerivedClass : public BaseClass {
public:
    void accessBaseFunctions() {
        // privateFunction(); // エラー: privateメンバ関数にはアクセスできない
        protectedFunction(); // OK: protectedメンバ関数にはアクセスできる
    }
};
int main() {
    DerivedClass obj; // 派生クラスのインスタンス
    obj.callProtectedFunction(); // publicメンバ関数を通じてprotectedメンバ関数を呼び出す
    obj.accessBaseFunctions(); // 派生クラスからのアクセス
    return 0;
}

BaseClassのprotectedFunctionが呼び出されました。
BaseClassのprotectedFunctionが呼び出されました。

[capture](parameters) -> return_type {
    // 関数の本体
}

#include <iostream>
using namespace std;
int main() {
    auto lambda = []() { // ラムダ式の定義
        cout << "こんにちは、ラムダ式！" << endl;
    };
    lambda(); // ラムダ式の呼び出し
    return 0;
}

こんにちは、ラムダ式！

#include <iostream>
using namespace std;
class MyClass {
public:
    void display() { // メンバ関数
        cout << "メンバ関数が呼び出されました。" << endl;
    }
    void callLambda() {
        auto lambda = [this]() { // thisポインタをキャプチャ
            display(); // メンバ関数の呼び出し
        };
        lambda(); // ラムダ式の呼び出し
    }
};
int main() {
    MyClass obj; // インスタンスの生成
    obj.callLambda(); // ラムダ式を通じてメンバ関数を呼び出す
    return 0;
}

メンバ関数が呼び出されました。

#include <iostream>
using namespace std;
class MyClass {
public:
    void display(int value) { // メンバ関数
        cout << "値: " << value << endl;
    }
    void callLambda() {
        int num = 10;
        auto lambda = [this, num]() { // thisポインタとnumをキャプチャ
            display(num); // メンバ関数の呼び出し
        };
        lambda(); // ラムダ式の呼び出し
    }
};
int main() {
    MyClass obj; // インスタンスの生成
    obj.callLambda(); // ラムダ式を通じてメンバ関数を呼び出す
    return 0;
}

値: 10

#include <iostream>
#include <functional> // std::functionを使用
using namespace std;
class MyClass {
public:
    void process(function<void()> callback) { // コールバック関数を受け取る
        cout << "処理中..." << endl;
        callback(); // コールバック関数の呼び出し
    }
};
int main() {
    MyClass obj; // インスタンスの生成
    // ラムダ式を使ったコールバック関数の定義
    obj.process([]() {
        cout << "コールバック関数が呼び出されました。" << endl;
    });
    return 0;
}

処理中...
コールバック関数が呼び出されました。