从模板类的另一个实例创建模板类的实例时省略模板参数

Omit template arguments when create an instance of template class from another instance of template class

本文关键字：实例 参数 时省 另一个 创建 建模      更新时间：2023-10-16

我想在创建类DeriveGenerator<T3,T4,T1,T2>实例时省略一些模板参数T1,T2以安慰我的生活。

这是我遇到的最终简化版本。

我的图书馆：-

重要的部分是类声明。 (this line)
他们的内部内容只是一个填充物。

template<class T1,class T2>class BaseGenerator{ //<-- this line
public: std::pair<T1*,T2*> generateBase(){ 
/** actually create T3,T4 internally */
return std::pair<T1*,T2*>(nullptr,nullptr);
}
};
template<class T3,class T4,class T1,class T2>class DeriveGenerator{ //<-- this line
public: Base<T1,T2>* base;
public: std::pair<T3*,T4*> generateDerive(){ 
auto pp=base->generateBase();
return std::pair<T3*,T4*>((T3*)(pp.first),(T4*)(pp.second));
}
};

用户：-

class B1{};class B2{};
class B3:public B1{};
class B4:public B2{};
int main() {
//v this is what I have to
BaseGenerator<B1,B2> baseGen;
DeriveGenerator<B3,B4,B1,B2> deriveGen;  //so dirty #1
deriveGen.base=&baseGen;
deriveGen.generateDerive();
}

问题

是否可以使生产线#1更清洁？
我想要deriveGen的类型取决于baseGen的类型。

这是我的愿望：-

BaseGenerator<B1,B2> baseGen;
DeriveGenerator<B3,B4> deriveGen;   //<-- modified
deriveGen.base=&baseGen;

或至少像这样：-

BaseGenerator<B1,B2> baseGen;
DeriveGenerator<B3,B4, DECLARATION_TYPE(baseGen) > deriveGen;   //<-- modified
deriveGen.base=&baseGen;

我已经阅读(仍然没有线索)：-

  • 在C++模板中省略参数
  • 跳过C++模板参数
  • 省略C++模板参数列表时的区别

我什至不知道这是否可能。

">decltype"似乎是最接近的线索，但我找不到将其应用于这种情况的方法。
我想我可能不得不把它分成T1,T2....(?)

编辑

在实际情况下，baseGen是某些类的非静态字段，尚未实例化，例如

class Holder{
public: BaseGenerator<B1,B2> baseGen;
};

所以在申报deriveGen的时候，我无法达到baseGen的真实实例。
这是困难的部分。

不过，我可以通过decltype来引用baseGen的类型。
(对不起没有提及)

如果可以将派生生成器定义更改为：

template<class T3, class T4, class BaseT>
class DeriveGenerator{
public:
BaseT* base = nullptr;
std::pair<T3*, T4*> generateDerive(){ 
auto pp = base->generateBase();
return {(T3*)(pp.first), (T4*)(pp.second)};
}
};

您可以使用：

BaseGenerator<B1, B2> baseGen;
DeriveGenerator<B3, B4, decltype(baseGen)> deriveGen;

否则，我建议创建一个助手：

template <typename B3, typename B4, typename B1, typename B2>
DeriveGenerator<B3, B4, B1, B2>
MakeDerived(BaseGenerator<B1, B2>& baseGen)
{
DeriveGenerator<B3, B4, B1, B2> deriveGen;
deriveGen.base = &baseGen;
return deriveGen;
}

，然后使用

BaseGenerator<B1,B2> baseGen;
auto deriveGen = MakeDerived<B3, B4>(baseGen);

不确定你想要什么，但是...我想你可以这样定义DeriveGenerator

template <typename, typename, typename>
class DeriveGenerator;
template <typename T3, typename T4, typename T1, typename T2>
class DeriveGenerator<T3, T4, BaseGenerator<T1, T2>>
{
public:
BaseGenerator<T1,T2>* base;
public:
std::pair<T3*,T4*> generateDerive ()
{ 
auto pp=base->generateBase();
return std::pair<T3*,T4*>((T3*)(pp.first),(T4*)(pp.second));
}
};

并按如下方式使用它

BaseGenerator<B1,B2> baseGen;
DeriveGenerator<B3,B4,decltype(baseGen)> deriveGen;

如果你对T1和T2类型感兴趣;如果你只对BaseGenerator<T1, T2>感兴趣，你可以简单地写

template <typename T3, typename T4, typename Tbase>
class DeriveGenerator
{
public:
Tbase * base;
public:
std::pair<T3*,T4*> generateDerive ()
{ 
auto pp=base->generateBase();
return std::pair<T3*,T4*>((T3*)(pp.first),(T4*)(pp.second));
}
};

我认为将DeriveGenerator的T1和T2模板参数推送到实际的generateDerive方法本身中更简单：

template<class T3,class T4>
class DeriveGenerator{ 
public: 
template<class T1, class T2, template<class, class> class Base>
std::pair<T3*,T4*> generateDerive(Base<T1, T2>* base){
static_assert(std::is_base_of<T1, T3>::value && std::is_base_of<T2, T4>::value, "T1 should be base of T3 and T2 should be base of T4"); 
auto pp=base->generateBase();
return std::pair<T3*,T4*>((T3*)(pp.first),(T4*)(pp.second));
}
};

演示

现在你可以这样称呼它：

BaseGenerator<B1,B2> baseGen;
DeriveGenerator<B3,B4> deriveGen;
deriveGen.generateDerive(&baseGen);

我在DeriveGenerator::generateDerive中添加了一个static_assert，以确保使用std::is_base_of正确进行基本/派生配对，以便在不小心弄乱模板参数时会出现编译器错误。

class B5{}; // new class B5 nobody inherits from
BaseGenerator<B1, B5> bad_baseGen;
deriveGen.generateDerive(&bad_baseGen);
相关文章：