templateを使って異なるクラスのインスタンスを作成したい

Question

###前提・実現したいこと
異なる型のインスタンスを作成する関数を作成しています。
作成する型が異なる以外はすべて処理が同じためtemplate関数を使用して実装を共通化しようとしているのですが、内部で使用する型をテンプレートで指定する方法が分かりません。
引数や戻り値でtemplate引数を使用しない場合、template関数は使用できないのでしょうか？

###該当のソースコード

template<typename TClass>std::shared_ptr<SuperClass> Create(type)
{
return std::make_shared<TClass>()
}

TClassはSuperClassを継承している想定です。
typeでTClassの型を動的に切り替えたいと考えています。
たとえばtype-AならClassAのインスタンスを、type-BならClassBのインスタンスを作成するような感じです。

Comments

[yohhoy]

生成するインスタンス型は、パラメータtypeで実行時に指定したいという事でしょうか？テンプレート引数に型を与えるという事は、コンパイル時に型を決めることですから、要求自体が矛盾していませんか？

[hoge_beginner]

typeで実行時に型を指定できないかと考えています。
Create関数内でtypeを使ってswitch,caseをすれば実現できるのですが、今後typeが追加される可能性があり極力Create関数を変更しないで対処できないか考えている次第です。

Answer 1

「今後typeが追加される可能性があり極力Create関数を変更しないで対処」とのことなので、Boostライブラリなども使えば実現可能ではあります。（使わなくても書けますがさらに面倒）

クラスが増えてもDrivedBを増やすだけでメンテナンス可能です。が、そこまでする価値があるかは状況次第でしょうね。

#include <cassert>
#include <memory>
#include <iostream>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/for_each.hpp>
namespace mpl = boost::mpl;

// 基底クラスB
struct B { virtual void f() = 0; };
// Bから派生したクラスX,Y,Z
struct X : B { void f() { std::cout << "I'm X" << std::endl; } };
struct Y : B { void f() { std::cout << "I'm Y" << std::endl; } };
struct Z : B { void f() { std::cout << "I'm Z" << std::endl; } };
// B派生クラスの型リスト
using DrivedB = mpl::vector<X, Y, Z>;

// 無関係なクラス
struct Other {};


template <typename TypeList>
std::shared_ptr<B> Create(const std::type_info* type)
{
  std::shared_ptr<B> result = nullptr;
  mpl::for_each<TypeList>([&](auto& T) {
    if (!result && typeid(T) == *type) {
      result = std::make_shared<std::decay_t<decltype(T)>>();
    }
  });
  return result;
}

int main()
{
  auto* type = &typeid(X);
  std::shared_ptr<B> px = Create<DrivedB>(type);
  px->f();  // shared_ptr<X>

  type = &typeid(Y);
  std::shared_ptr<B> py = Create<DrivedB>(type);
  py->f();  // shared_ptr<Y>

  type = &typeid(Other);
  std::shared_ptr<B> po = Create<DrivedB>(type);
  // OtherクラスはDrivedBリストに含まれないためnullptrを返す
  assert(po == nullptr);
}

Answer 2

こういうことでしょうか。

template <typename TClass>
std::shared_ptr<SuperClass> Create()
{
	return std::shared_ptr<SuperClass>(new TClass);
}


int main()
{
	// SubClassAとSubClassBはSuperClassの派生クラス
	auto pa = Create<SubClassA>();
	auto pb = Create<SubClassB>();

	return 0;
}

テンプレート引数は<>で括って渡せば良くて、関数の引数は不要です。

Answer 3

こんにちは。

typeでTClassの型を動的に切り替えたいと考えています。

動的ということは、typeはSuperClassのポインタか参照でしょうか？ もし、YESならyohhoyさんも指摘されているように、無理です。基底クラスのポインタが指すインスタンスの型をコンパイラは把握できませんので、TClassを型推論することは不可能なのです。
しかし、もし、typeがTClassのポインタか参照ならば可能です。普通に型推論できます。

あ、しかし、std::shared_ptr<TClass>をstd::shared_ptr<SuperClass>へ変換することはできない筈です。
TClassとSuperClass間に派生関係があっても、std::shared_ptr<TClass>とstd::shared_ptr<SuperClass>の間には派生関係がありませんから。
派生関係があると言うことは、下記イメージの定義が存在するということです。

class shared_ptr<TClass> : public shard_ptr<SuperClass> { };

本当にやりたいことを整理された方が良いと思います。

Answer 4

例えば、次のようなテンプレート関数があるとします。

template <typename X>
X max(X var1 , X var2){
    if(var1 > var2) return var1;
    else    return var2;
}

このテンプレート関数を呼び出すコードは、以下のようになります。

max<double>(2.718, 3.14);

見慣れない表記があるかもしれません。これは、テンプレートの型を省略しない書き方です。

要するに、テンプレートを呼び出すときに、必要となる型を省略せずに書けばいいと思うのです。
質問の意図と違っていたらごめんなさい。

Comments

[hoge_beginner]

回答ありがとうございます。
テンプレートの型を呼び出し側で指定する記述があったんですね。
typeでswitch,caseを行いcreate関数を呼ぶときに型指定をすることで期待した処理が実現できました。