あるクラスに、機能の集まりFから、出来ることをいくつか選択させたい

Question

前提・実現したいこと

あるクラスが、機能の集まりFから、出来ることをいくつか選択し、そのクラスに選択した機能以外の機能が関連付けられた場合（例えば、関数の引数においてオブジェトと機能を選択させたとき）、コンパイルエラーとしたいです。

詳細

基底クラスを、

class Base {
public:
  virtual void execute(Base base, F f) final {
  }
  virtual void A() = 0;
};

とします。
派生クラスは、

class Derived: public Base {
};

単にこのような感じです。
（純粋仮想関数の定義等は省略します）

ここで、この Base を継承したクラス Derived は、F の機能群のうち、どの機能を使えるように示すにはどのように構成したら良いでしょうか。
機能群Fというのも曖昧ですが、何らかのクラスの集まりなどのつもりです。
そうでなくてもよいです。

例

意味が分からないと思いますので、こちらの例を参考にして下さい。
しかし、例も意味不明かもしれません。

#include <iostream>

class PolicyA { // 機能A。やることは、この中で完結している
public:
	virtual void policyA() {
		std::cout << "policyA" << std::endl;
	}
};
class PolicyB { // 機能B。やることは、この中で完結している
public:
	virtual void policyB() {
		std::cout << "policyB" << std::endl;
	}
};

class Base {
public:
	template <typename T>
	void execution(T *derived, void (T::*policy)()) {
		(derived->*policy)();
	};
};
class DerivedWithPolicyA final : public Base, public PolicyA {
public:
	virtual void policyA() override {
		PolicyA::policyA();
	}
	void calc() {
		execution(this, &DerivedWithPolicyA::policyA);
		// execution(this, &DerivedWithPolicyB::policyB); エラーにできる
	}
};
class DerivedWithPolicyB final : public Base, public PolicyB {
public:
	virtual void policyB() override {
		PolicyB::policyB();
	}
	void calc() {
		execution(this, &DerivedWithPolicyB::policyB);                   // ok
		execution(new DerivedWithPolicyA, &DerivedWithPolicyA::policyA); // ok
	}
};
int main() {
	DerivedWithPolicyA a;
	a.calc();

	DerivedWithPolicyB b;
	b.calc();
}

こういう感じの事をしたいです。。伝わりましたでしょうか。。
Base の情報しか持っていない人は、execution を呼べる必要はないです。
（呼べたらむしろ変）

上述の例に対する不満

(1) 関数ポインタの型さえ合えば、Policy 系(PolicyAやPolicyB)でなくとも、自分で作ったものも呼べてしまうこと（Policy 系かどうかは、例えば Policies のような共通のクラスを継承することで識別することにする）
(2) 継承先で policyA や policyB を override しなければいけないこと（policyA と全く同じ処理を常にさせたいのに、冗長な上に、違う処理も書けてしまう）

上述の例で成功している点

・execution(this, &DerivedWithPolicyB::policyB); エラーにできる
このコンパイルエラーにできるという点です。
コンパイルエラーにするのは必須です。

補足

ここで、冒頭にあげた機能群Fは、今回の例では、F = {policyA, policyB} ということであり、DerivedWithPolicyA クラスは PolicyA を継承しており、かつ policyA をオーバーライドしているため、policyA という機能が使える　ことが示せています。

なお、上記例では機能はそれぞれ1つしか使えませんが、複数の機能を使えることもあります。

Comments

[yuki23]

Baseとその派生クラスはpolicyとどのような関係ですか？（メンバーを使う？ 引数にする？など。それとも無関係？）

[tails]

policyは、Baseやその派生クラスを全く使用しません。
そのクラスを参照することすらありません。
無関係になります。

[yuki23]

つまり、ある関数 policyX を特定のクラス Y のインスタンスがある場所からだけ呼べるようにしたいということですか？

[yuki23]

自分自身がそのクラスでなくてもいい、というのは意味がよくわかりませんが……（インスタンスが作れさえすれば、どこからでも呼べていいのか？）

[tails]

すみません、ごちゃごちゃやってたら、解決してました。。
自己解決欄のコードのようなことをしたかったのです。

[maai]

例えば、機能{A,B,C}があって、あるクラスが{A,B}を選んだのにCを呼び出そうとしたからコンパイルエラーが発生する、で合っていますか？これだと多重継承だけでできそうに見えるので違う気がしますが…

[tails]

それであっています。
ただ、それらの機能は基底クラスで実行させたいのです。
よく分からなくてすみません。
別の具体例で再質問しようと思います。

Answer 1

#include <iostream>
#include <type_traits>

class PolicyA {
public:
	virtual void policyA() final {
		std::cout << "policyA" << std::endl;
	}
};
class PolicyB {
public:
	virtual void policyB() final {
		std::cout << "policyB" << std::endl;
	}
};

class Base {
private:
	class Policies : public PolicyA, public PolicyB {};

public:
	template <
	    typename S, typename T,
	    std::enable_if_t<std::is_base_of<T, Policies>::value, std::nullptr_t> =
	        nullptr,
	    std::enable_if_t<std::is_base_of<T, S>::value, std::nullptr_t> = nullptr>
	void execution(S &derived, void (T::*policy)()) {
		(derived.*policy)();
	};
};
class DerivedWithPolicyA final : public Base, public PolicyA {
public:
	void calc() {
		execution(*this, &PolicyA::policyA); // これもok
		// execution(*this, &PolicyB::policyB); // error!
	}
};
class DerivedWithPolicyB final : public Base, public PolicyB {
public:
	void calc() {
		execution(*this, &DerivedWithPolicyB::policyB);                // ok
		execution(DerivedWithPolicyA(), &DerivedWithPolicyA::policyA); // ok
		// execution(*this, &DerivedWithPolicyB::test); error!
		// execution(*this, &DerivedWithPolicyA::policyA); error!
	}
};
int main() {
	DerivedWithPolicyA a;
	a.calc();

	DerivedWithPolicyB b;
	b.calc();
}