【C++】継承したクラス関数について【rust】

Question

C++もRUSTも初心者です。休日プログラマーなので頼れる方もおらず、
どなたかご教授ください。

以下のコードでは、HOGEクラスで定義したhoge関数を、AAA＆BBBクラスに継承している単純なコードなのですが・・・

#include <string>

class HOGE{
public:
	void hoge(unsigned short ccc);
};

void HOGE::hoge(unsigned short ccc){
	printf("VALUE = %d\n", ccc);
}


class AAA : public HOGE{
public:
	unsigned short aaa;
};

class BBB : public HOGE{
public:
	unsigned short bbb;
};



int main(){

	AAA obj;

	obj.aaa = 10000;
	obj.hoge(obj.aaa);

	BBB obj2;

	obj2.bbb = 20000;
	obj2.hoge(obj2.bbb);
}

//実行結果
VALUE = 10000
VALUE = 20000

この継承されるhoge関数の内容自体をAAAクラス、BBBクラスで異なる内容にしたい、かつ宣言はHOGEクラスにて行いたい場合には
どのように記述したらよいでしょうか。
イメージとしてはRUSTのpub trait HOGE内の関数を「impl HOGE for AAA」のように使用する場合と同じ記述をc++でしたいです。

拙い説明で恐縮ですが、よろしくお願いいたします。

Answer 1

結論から言えば出来ません。 継承やその他の宣言で特定のインターフェイスを満たしていることを表明する直接的な方法は用意されていません。

C++ の仮想関数 (virtual) を使った定義はわかりやすいのですがそれは Rust で言うところの dyn のようなもので実行時のポリモーフィズムを実現する機能です。 トレイトに dyn を付けるだけで動的なポリモーフィズムが出来る Rust はうらやましいですね。

あえていうなら必要なメンバを持っているかどうかを判定するメタ関数を作り static_assert で検査するという方法は考えられます。

#include <type_traits>
#include <iostream>

template<class T>
class has_hoge {
  template<class U, void (U::*)(unsigned short)>
  struct helper_t { typedef T type; };

  template<class U, class V = T>
  struct helper : std::false_type {};

  template<class U>
  struct helper<U, typename helper_t<U, &U::hoge>::type> : std::true_type {};

public:
  static const bool value = helper<T>::value;
};

class AAA {
public:
  unsigned short aaa;
  void hoge(unsigned short ccc){
    std::cout << "VALUE = " << ccc << std::endl;
  }
};

static_assert(has_hoge<AAA>::value, "AAA has not hoge");

class BBB {
public:
  unsigned short bbb;
  void hoge(unsigned short ccc) {
    std::cout << "VALUE = " << ccc << std::endl;
  }
};

static_assert(has_hoge<BBB>::value, "BBB has not hoge");

int main(){

  AAA obj;

  obj.aaa = 10000;
  obj.hoge(obj.aaa);

  BBB obj2;

  obj2.bbb = 20000;
  obj2.hoge(obj2.bbb);
}

ただ、メタ関数の作り方はテンプレートの特殊化の規則をよく理解しないと作れません。 初心者が上の例をいくら眺めても理解不能でしょう。

最新の C++ (C++20) では型の制約を直接的に表現できる concept と呼ばれる機能が登場しましたが、 Rust の impl とは全く違います。

Comments

[ddp]

返信おそくなりました。
static_assertというものを初めて知りました。これは別途活用していきたいと思います。ありがとうございます。
私のrustに関する知識も相当拙劣なので、そもそもimpl HOGE for hogeが「特定のインターフェイスを満たしていることを表明する」検証機能を備えていること自体知りませんでした。
私が満たしたい内容としては、とあるクラスで宣言してある関数をそのほかのクラスで別々に実装できれば良いと考えているので、virtualで問題ないと考えていますがどうでしょうか。

[SaitoAtsushi]

繰り返しますが virtual は呼び出すべき関数を実行時に選択する仕組みです。 抽象クラスの継承は結果的に特定のインターフェイスを強制することも含まれるとはいうものの、実行時ポリモーフィズムを活用しないときに実行時ポリモーフィズムのための言語機能を使うということを問題ないと考えるのは一般的ではないでしょうね。

mitama_rs さんのコードがわざわざ invoke_hoge を経由しているのは、実行時ポリモーフィズムのための言語機能を使うから実行時ポリモーフィズムが活用される形で例を示しているのです。 そうする必要がないのであれば抽象クラスを使うべきではありません。

[ddp]

正直なところ、抽象クラスを使うべきか（多相化する必要があるのか）よくわからなくなってきました。
ご丁寧に説明頂きありがとうございます。
もう少し自身で勉強してみます。

[SaitoAtsushi]

ちょっと説明が不足していたので補足。

私が「実行時」という言葉を省略せずに書いているのは、逆に言えば実行時ではない多相があるということです。 多相には大きくわけて実行時のものとコンパイル時のものがあるということを意識してください。 (単にポリモーフィズムと言ったときにどちらかだけのことを指しているような資料もあるので注意を要するのですが。)

抽象クラスは実行時の多相を実現するもので、コンパイル時の多相はテンプレートでおこなうというのが C++ での役割分担です。 (Rust だとどちらもトレイトでやってしまえるようになっています。)

[ddp]

>>抽象クラスは実行時の多相を実現するもので、コンパイル時の多相はテンプレートでおこなうというのが C++ での役割分担です。
・・の部分について、今の私には正直よくわかりません。
一つお聞きしたいのですが、ポリモーフィズム、多相化のメリットというのは何処にあるのでしょうか？
mitama_rsさんの例にあるinvoke_hogeについても、それぞれobj.hoge()、obj2.hoge()とすれば良いと思えてしまうのですが・・。
お時間ありましたらご返答ください。

[SaitoAtsushi]

invoke_hoge に意味が見いだせないという理解は逆です。 invoke_hoge のようなものが必要になったときに多相が必要になるという説明なのです。

obj.hoge() 、 obj2.hoge() とすればよいときはそれでよいです。 そしてそのときには多相も不要です。

Answer 2

C++では、つぎのように書きます。

#include <iostream>
class HOGE{
public:
    virtual void hoge(unsigned short ccc) const = 0;
};

class AAA : public HOGE{
public:
    void hoge(unsigned short ccc) const override {
        printf("AAA: VALUE = %d\n", ccc);
    }
};

class BBB : public HOGE{
public:
    void hoge(unsigned short ccc) const override {
        printf("BBB: VALUE = %d\n", ccc);
    }
};

void invoke_hoge(HOGE const& hoge, unsigned short v) { hoge.hoge(v); }

int main(){

    AAA obj;

    invoke_hoge(obj, 10000); // AAA: VALUE = 10000

    BBB obj2;

    invoke_hoge(obj2, 20000); // BBB: VALUE = 20000
}

まず、基底クラスHOGEでvirtual void hoge(unsigned short ccc) const = 0;と宣言します。
これはpure virtual functionというもので、実装をもちません。

AAA、BBBではHOGEを継承し、仮想関数hogeをオーバーライドします。
基底クラスの仮想関数と同じシグネチャの関数を書くとオーバーライドされます。
Rustのimplのような専用の文法はありません。

このAAAやBBBの変数をHOGEの参照（もしくはポインタ）として渡すと、hoge(...)の呼び出しはオーバーライドされたものが呼び出されます。

Comments

[ddp]

返信遅くなりました。
pure virtual functionというもの自体知りませんでした。
こちらで確かに用件を満たせそうですが、中断のinvoke_hoge関数はどういった意味がありますか？
ネットで純粋仮想関数について調べたところ、以下のリンクに行き着きまして、
https://kaworu.jpn.org/cpp/%E7%B4%94%E7%B2%8B%E4%BB%AE%E6%83%B3%E9%96%A2%E6%95%B0
invoke_hogeのような記述はなく、たしかになくても実装できそうな気がしています。
何かテクニックが潜んでいそうなのでご面倒でなければ解説をお願いできないでしょうか。
よろしくお願いします。

[mitama_rs]

`AAA obj; obj.hoge(10000);` だと、ただAAAのメンバ関数を呼び出しているだけです。
なんの多相性もありません。
ですので、HOGEとして受け取ってhoge関数を呼び出すために例としてinvoke_hogeを経由させています。

[ddp]

了解しました。
たしかに多相性は無いように思われます。
ご丁寧にご説明頂きありがとうございます。