クラスの設計が上手く行かず、dynamic_castを使用してしまう

Question

以下のような形のソースコードをdynamic_castを使わずに実行したいのですが、上手く行きません。何か方法はないのでしょうか？

class Foo
{
   Foo();
   virtual void bar()=0;
}
class Foo_A
{
   Foo_A();
   virtual void bar();
   double baz();
}

class Foo_B
{
   Foo_B();
   virtual void bar();
   int qux(int num);
}

//関数の実装は省略

int main()
{
   Foo* arr[100];
   for(int i=0;i < 100;i++)
   {
      //random()は乱数を呼ぶ関数
      if(random()%2 == 1)
      {
     arr[i] = new Foo_A();
      }
   else 
      {
     arr[i] = new Foo_B();
      }
   }
    
   Foo_A* foo_a;
   Foo_B* foo_b   
   
   //この部分でdynamic_castを使用してしまう
   for(int i=0;i<100;i++)
   {
      foo_a=dynamic_cast<Foo_A*>(vec[i]);
      foo_b=dynamic_cast<Foo_B*>(vec[i]);
      //random()は乱数を呼ぶ関数
      if(foo_a!=nullptr)
      {
     arr[i].baz();
      }
   else if(foo_b!=nullptr)
      {
     arr[i].qux(10);
      }
   }
   //メモリの解放は省略
}

このようにdynamic_castを使って遅いソースコードになってしまいます。dynamic_castやダウンキャストは余り使用したくありません。

本来ならば動的ポリモーフィズム等を駆使してint qux(int num)とdouble baz()を一つの純粋仮想関数にし、派生先で実際の動作を別々に実装するべきなのでしょうが、実際のコードではどうしても戻り値と引数が異なる形になってしまい、上手くまとめる事が出来ません。

このような問題に対してはdynamic_castを使って実装をするしか手はないのでしょうか？それとも何か別の方法があるのでしょうか？よろしくお願いします。

Answer 1

ポリモーフィズムはインターフェイスが共通するものを同じように扱えますが、インターフェイスが異なるという条件では dynamic_cast を使わざるを得ません。 他の方法を考えるにしても、そもそもの設計を見直さないと似たような不恰好さをかかえてしまうと思います。

が、その不恰好さを隠す方法はいくつか考えられます。

たとえば単にマクロとして

#define foo_action(elm, case_a_func, case_b_func)       \
  if(Foo_A* foo=dynamic_cast<Foo_A*>(elm)) {            \
    foo->case_a_func;                                   \
  } else if(Foo_B* foo=dynamic_cast<Foo_B*>(elm)) {     \
    foo->case_b_func;                                   \
  }

というように定義しておけば、呼出しの箇所では

for(int i=0;i<100;i++) {
  foo_action(arr[i], baz(), qux(10));
}

という風になるので、少し見通しがよい気がします。 (設計としてアレなのはかわりませんが。)

ただ、質問の例ではメンバ関数の返却値を利用していませんが、実際には利用するわけですよね。 そこらへんをどうしたものかと思うのですが、 Foo_A のとき、 Foo_B のときそれぞれのときにどうするかをラムダ式で与えられるようにすれば自由度の高い表現ができるのではないかと思います。

つまり、

#include <functional>

void foo_action(Foo* e, std::function<double(Foo_A*)> a, std::function<int(Foo_B*)> b) {
  if(Foo_A* foo=dynamic_cast<Foo_A*>(e)) a(foo);
  else if(Foo_B* foo=dynamic_cast<Foo_B*>(e)) b(foo);
}

というような関数を定義しておけば

for(int i=0;i<100;i++) {
  foo_action(arr[i],
             [](Foo_A* e){return e->baz();},
             [](Foo_B* e){return e->qux(10);});
}

という風に呼出せます。

返却値に対して何か処理したいことがあるのであればラムダ式の中に書けばよいわけです。 マクロよりは (型で制約されるので) マシかなという感じです。

Comments

[KureteRubyLua]

結局設計そのものを一から見直しました。

どうも有難うございました。

Answer 2

こんにちは。

あまりスマートな方法は思いつきませんでした。

まず、static_cast<>でダウンキャストする方法が考えられます。
virtual is_Foo_A();のような仮想関数を設けて、その結果でstatic_cast<>です。

ダウンキャストしない方法としては、上記のis_Foo_A()に加えて、baz()とqux()の両方とも純粋でない仮想関数にしてFoo_AとFoo_Bは必要な方だけ定義し、必要に応じて呼び分ける感じでしょうか。

どちらにしてもあまりスマートではないですね。ダウンキャストしますが前者の方がまだましかなとは思います。

llvmに含まれるlibToolingはdyn_cast<>という関数テンプレートでダウンキャストしてます。
linux上のlibToolingはRTTIを禁止してビルドしてあるのでdynamic_cast<>は使えませんでした。なので、dyn_cast<>の実装にはstatic_cast<>かreinterpret_cast<>が使われている筈です。多重継承に対応するために、恐らくstatic_cast<>だろうと思います。
つまり、llvmのdyn_cast<>は（もっと洗練されてますが）、前者と大差はない実装だろうと思います。

Answer 3

実際の背景情報までは分かりませんが、掲示コードの範囲だとdynamic_castを使わざるを得ないように思えます。

型(type)による処理分岐を行う場合、C++言語機能としては「仮想関数(virtual function)」か「RTTI＋dynamic_cast」が利用できます。関数インタフェース（引数型や戻値型）を揃えることが困難ということであれば、後者のようにRTTIに基づく処理分岐しか解法が無いと思います。

---

このようにdynamic_castを使って遅いソースコードになってしまいます。dynamic_castやダウンキャストは余り使用したくありません。

本質的にはdynamic_cast相当処理が必要になるかと思いますが、専用実装を行うことで実行時オーバーヘッドを下げることはできます。（一般性を失ったdynamic_castの再実装）

class Foo_A;
class Foo_B;

class Foo {
   virtual Foo_A* asA() { return nullptr; }
   virtual Foo_B* asB() { return nullptr; }
};

class Foo_A : public Foo {
   double baz();
   virtual Foo_A* asA() override { return this; }
};

class Foo_B : public Foo {
   int qux(int num);
   virtual Foo_B* asB() override { return this; }
};

if (Foo_A* foo_a = vec[i].asA()) {
  foo_a->baz();
} else if (Foo_B* foo_b = vec[i].asB()) {
  foo_b->qux(10);
}

Answer 4

平凡な回答ですが、異なる操作baz,quxを持つFoo_AとFoo_Bがあり、それでもなおそれらをFooとして統一的に扱うような必要があるのであれば、やはりbazとquzはvirtualとして設計してはいけないでしょうか。

Fooにはbaz,quxともにデフォルト実装としてIllegalOperationExceptionを発するようなデフォルト実装をしておき、Foo_Aにはbazのみoverride, Foo_Bにはquxのみoverrideする感じです。

Chironianさんがおっしゃるように呼び出し側でbaz,quxをそのインスタンスに対して呼び出していいかどうかの判定が必要になりますが、判定を間違えてIllegalOperationExceptionが発せられてしまう危険とキャストが実行時に失敗する危険は「同じこと」という考え方です。

Fooの定義を自分の自由にできない場合は無理ですが・・・

Answer 5

外からFooのAとBを同じように扱うことを考えよう
サンプルからじゃマジックナンバーである10とかがどういう扱いなのかがわからない

呼び出すだけで良いならhmmmさんのように事前に全てやっておくという方法もあるし
共通の引数の型に一旦ぼかすという方法もある。

呼び場所で識別して引数をどうしても代入しなきゃならないならそもそもこういう形にはあまりしないけど、予備元も呼び出しルールを把握していれば、1個の関数を経由するようにはできるよ。

下記のルールなら、vector<void*>と一緒にFooを特定する方法を書くことによってディスパッチする機能を作ることはできるよ。

enum FooType
{
    FtA,
    FtB
}

class Foo
{
public:
   virtual FooType GetType();
   // vector<void*>型は要件を満たせばなんでも良い
   // ただ、この型を多機能にすると共通化は簡単になっていく
   virtual void calc(const vector<void*> &args)= 0;
}

class Foo_A
{
public:
   virtual FooType GetType() override {
       return FtA;
   }
   virtual void calc(const vector<void*> &args) override {
        // いらない場合無視する
        baz();
   }
}

class Foo_B
{
public:
   virtual FooType GetType() override {
       return FtB;
   }
   virtual void calc(const vector<void*> &args) override {
        // argsの長さとかをチェックしてキャストしながら突っ込む
        qux((int)args[0]);
   }
}

int main()
{
   Foo* arr[100];
   for(int i=0;i < 100;i++)
   {
      //random()は乱数を呼ぶ関数
      if(random()%2 == 1)
      {
         arr[i] = new Foo_A();
      }
      else 
      {
         arr[i] = new Foo_B();
      }
   }

   vector<void*> empty;
   Foo *foo;
   for(int i=0;i<100;i++)
   {
       // vec[i] って arr[i]のこと？
       foo = arr[i];

       // ここでfooを識別しなくてよい方法があればより良い
       switch(foo->GetType())
       {
           default: foo->calc(empty); break;
           case FtB: {
               vector<void*> args;
               args.push_back(10);
               foo->calc(args);
           }   break;
       }
   }

   //メモリの解放は省略
}

ちょっと動作確認まではしてないからあれだけどね。

#追記

一応よりよい形はこんな感じかな

struct Request
{
   FooType Type;
   vector<void*> Args;
}

int main()
{
   // Fooのそれぞれの実装を登録する
   std::map<FooType, Foo*> fooMap;
   fooMap[FtA] = new Foo_A();
   fooMap[FtB] = new Foo_B();

   // リクエストはどのFooに何の引数を渡すかだけ知っている
   Request arr[100]; // ※ちょっとこんな風に配列にできたか定かじゃないが…
   for(int i=0;i < 100;i++)
   {
      //random()は乱数を呼ぶ関数
      if(random()%2 == 1)
      {
         arr[i].Type = FtA;
      }
      else 
      {
         arr[i].Type = FtB;
         arr[i].Args.push_back(10);
      }
   }

   // Requestの処理はFooの特定と渡された引数の移譲だけで良い
   for(int i=0;i<100;i++)
   {
       // 好きなFooの実装は FooType と std::vector<void*> の組み合わせがあれば呼び出せる
       fooMap[arr[i].Type]->calc(arr[i].args);
   }

   //メモリの解放は省略
}

Answer 6

何がしたいのかいまいち分からないんだけど継承使いたいなら以下のような感じにするんじゃないでしょうか。

class Foo
{
public:
   Foo();
   virutal ~Foo();
   virtual void bar()=0;
   virtual void calc() = 0;
}
class Foo_A
{
public:
   Foo_A();
   virutal ~Foo_A();
   virtual void bar();
   virtual void calc() override{
        baz();
   }
   double baz();
}

class Foo_B
{
public:
   Foo_B();
   virutal ~Foo_B();
   virtual void bar();
   virtual void calc() override{
        qux(num_);
   }
   void set_argument(int num){
       num_ = num;
   }
   int qux(int num);
   int num_;
}

//関数の実装は省略

int main()
{
   Foo* arr[100];
   for(int i=0;i < 100;i++)
   {
      //random()は乱数を呼ぶ関数
      if(random()%2 == 1)
      {
     arr[i] = new Foo_A();
      }
   else 
      {
     auto b = new Foo_B();
     b->set_argument(10);
     arr[i] = b;

      }
   }

   for(int i=0;i<100;i++)
   {
      vec[i]->calc();
   }
   //メモリの解放は省略
}