[C++] 派生クラスからのみ基底クラスの関数を呼べるようにする方法(protected)

#include <iostream>
using namespace std;
class Base {
protected:
    void protectedFunction() {
        cout << "基底クラスのprotected関数が呼ばれました。" << endl;
    }
};

#include <iostream>
using namespace std;
class Base {
protected:
    void protectedFunction() {
        cout << "基底クラスのprotected関数が呼ばれました。" << endl;
    }
};
class Derived : public Base {
public:
    void callProtectedFunction() {
        protectedFunction(); // 派生クラスから基底クラスのprotected関数を呼び出す
    }
};
int main() {
    Derived derived;
    derived.callProtectedFunction(); // 派生クラスの関数を通じて呼び出す
    return 0;
}

基底クラスのprotected関数が呼ばれました。

#include <iostream>
using namespace std;
class Base {
protected:
    void protectedFunction() {
        cout << "基底クラスのprotected関数が呼ばれました。" << endl;
    }
};
int main() {
    Base base;
    // base.protectedFunction(); // これはコンパイルエラーになります
    return 0;
}

#include <iostream>
using namespace std;
class PublicExample {
public:
    void publicFunction() {
        cout << "これはpublic関数です。" << endl;
    }
};
int main() {
    PublicExample example;
    example.publicFunction(); // 外部からアクセス可能
    return 0;
}

これはpublic関数です。

#include <iostream>
using namespace std;
class PrivateExample {
private:
    void privateFunction() {
        cout << "これはprivate関数です。" << endl;
    }
public:
    void callPrivateFunction() {
        privateFunction(); // 同じクラス内からはアクセス可能
    }
};
int main() {
    PrivateExample example;
    // example.privateFunction(); // これはコンパイルエラーになります
    example.callPrivateFunction(); // publicメソッドを通じて呼び出す
    return 0;
}

これはprivate関数です。

#include <iostream>
using namespace std;
class ProtectedExample {
protected:
    void protectedFunction() {
        cout << "これはprotected関数です。" << endl;
    }
};
class Derived : public ProtectedExample {
public:
    void callProtectedFunction() {
        protectedFunction(); // 派生クラスからアクセス可能
    }
};
int main() {
    Derived derived;
    derived.callProtectedFunction(); // 派生クラスの関数を通じて呼び出す
    // ProtectedExample example;
    // example.protectedFunction(); // これはコンパイルエラーになります
    return 0;
}

これはprotected関数です。

#include <iostream>
using namespace std;
class Base {
protected:
    void protectedFunction() {
        cout << "基底クラスのprotected関数が呼ばれました。" << endl;
    }
};
class Derived : public Base {
public:
    void callProtectedFunction() {
        protectedFunction(); // 派生クラスからprotected関数を呼び出す
    }
};
int main() {
    Derived derived;
    derived.callProtectedFunction(); // 派生クラスの関数を通じて呼び出す
    return 0;
}

基底クラスのprotected関数が呼ばれました。

#include <iostream>
using namespace std;
class Base {
protected:
    void protectedFunction() {
        cout << "基底クラスのprotected関数が呼ばれました。" << endl;
    }
};
class DerivedA : public Base {
public:
    void callProtectedFunction() {
        cout << "DerivedAからの呼び出し: ";
        protectedFunction(); // 派生クラスAから呼び出す
    }
};
class DerivedB : public Base {
public:
    void callProtectedFunction() {
        cout << "DerivedBからの呼び出し: ";
        protectedFunction(); // 派生クラスBから呼び出す
    }
};
int main() {
    DerivedA derivedA;
    derivedA.callProtectedFunction(); // DerivedAの関数を通じて呼び出す
    DerivedB derivedB;
    derivedB.callProtectedFunction(); // DerivedBの関数を通じて呼び出す
    return 0;
}

DerivedAからの呼び出し: 基底クラスのprotected関数が呼ばれました。
DerivedBからの呼び出し: 基底クラスのprotected関数が呼ばれました。

#include <iostream>
using namespace std;
class Base {
protected:
    void protectedFunction() {
        cout << "基底クラスのprotected関数が呼ばれました。" << endl;
    }
};
class Derived : public Base {
protected:
    void protectedFunction() override { // オーバーライド
        cout << "派生クラスのprotected関数が呼ばれました。" << endl;
    }
public:
    void callProtectedFunction() {
        protectedFunction(); // 派生クラスのprotected関数を呼び出す
    }
};
int main() {
    Derived derived;
    derived.callProtectedFunction(); // 派生クラスの関数を通じて呼び出す
    return 0;
}

派生クラスのprotected関数が呼ばれました。

#include <iostream>
using namespace std;
class AbstractClass {
protected:
    void templateMethod() {
        cout << "共通処理を実行中..." << endl;
        specificMethod(); // 派生クラスの特定処理を呼び出す
    }
    virtual void specificMethod() = 0; // 派生クラスで実装する純粋仮想関数
};
class ConcreteClassA : public AbstractClass {
protected:
    void specificMethod() override {
        cout << "ConcreteClassAの特定処理を実行中..." << endl;
    }
};
class ConcreteClassB : public AbstractClass {
protected:
    void specificMethod() override {
        cout << "ConcreteClassBの特定処理を実行中..." << endl;
    }
};
int main() {
    ConcreteClassA classA;
    classA.templateMethod(); // 共通処理と特定処理を実行
    ConcreteClassB classB;
    classB.templateMethod(); // 共通処理と特定処理を実行
    return 0;
}

共通処理を実行中...
ConcreteClassAの特定処理を実行中...
共通処理を実行中...
ConcreteClassBの特定処理を実行中...

#include <iostream>
using namespace std;
class Base {
protected:
    int value; // 派生クラスからアクセス可能な内部状態
public:
    Base(int v) : value(v) {}
};
class Derived : public Base {
public:
    Derived(int v) : Base(v) {}
    void displayValue() {
        cout << "内部状態の値: " << value << endl; // 派生クラスからアクセス
    }
};
int main() {
    Derived derived(42);
    derived.displayValue(); // 内部状態を表示
    return 0;
}

内部状態の値: 42

#include <iostream>
using namespace std;
class Character {
protected:
    int health;
    int attackPower;
public:
    Character(int h, int a) : health(h), attackPower(a) {}
    void takeDamage(int damage) {
        health -= damage;
        cout << "ダメージを受けた！残りの健康: " << health << endl;
    }
};
class Warrior : public Character {
public:
    Warrior(int h, int a) : Character(h, a) {}
    void attack(Character& target) {
        cout << "Warriorが攻撃！" << endl;
        target.takeDamage(attackPower);
    }
};
int main() {
    Warrior warrior(100, 20);
    Character enemy(80, 10);
    warrior.attack(enemy); // Warriorが敵を攻撃
    return 0;
}

Warriorが攻撃！
ダメージを受けた！残りの健康: 60