我整理了两个模板特化使用的代码片段，我认为它们特别奇怪，甚至可以说有些花哨。总的来说，我对使用模板来设计这些对象是否真的是最好的方式表示怀疑（尤其是第一个案例）。
哪种方法更好？为什么？或者是否有完全不同的方法更好？
1）将模板作为替代传递指向函数的指针：
//fusion_manager.h
template <typename InputFilterAlgorithm,
typename PredictionAlgorithm,
typename AssociationAlgorithm,
typename FusionAlgorithm>
class FusionManager
{
public:
FusionManager(Environment& env);
...
private:
Environment& env_m;
InputFilterAlgorithm filter_alg_m;
PredictionAlgorithm prediction_alg_m;
AssociationAlgorithm association_alg_m;
FusionAlgorithm fusion_alg_m;
...
};
//fusion_manager.cpp
template <typename InputFilterAlgorithm,
typename PredictionAlgorithm,
typename AssociationAlgorithm,
typename FusionAlgorithm>
FusionManager<InputFilterAlgorithm,
PredictionAlgorithm,
AssociationAlgorithm,
FusionAlgorithm,
TrackExtendedDataType>::FusionManager(Environment& env)
:
env_m(env),
filter_alg_m(env),
prediction_alg_m(env),
association_alg_m(env),
fusion_alg_m(env)
{
...
}
//main.cpp
...
FusionManager<TestInputFilterAlgorithm,
TestPredictionAlgorithm,
TestAssociationAlgorithm,
TestFusionAlgorithm> fusionManager(env);
...
...不要使用这样的方式：
//fusion_manager.h
class FusionManager
{
public:
//Let's say each algorithm is encapsulated by a class
FusionManager(Environment& env,
InputFilterAlgorithm&&,
PredictionAlgorithm&&,
AssociationAlgorithm&&,
FusionAlgorithm&&);
private:
Environment& env_m;
InputFilterAlgorithm filter_alg_m;
PredictionAlgorithm prediction_alg_m;
AssociationAlgorithm association_alg_m;
FusionAlgorithm fusion_alg_m;
};
//fusion_manager.cpp
FusionManager::FusionManager(Environment& env,
InputFilterAlgorithm&& filter_alg,
PredictionAlgorithm&& prediction_alg,
AssociationAlgorithm&& association_alg,
FusionAlgorithm&& fusion_alg)
:
env_m(env),
filter_alg_m(std::move(filter_alg)),
prediction_alg_m(std::move(prediction_alg)),
association_alg_m(std::move(association_alg)),
fusion_alg_m(std::move(fusion_alg))
{
...
}
//main.cpp
...
FusionManager<TestInputFilterAlgorithm,
TestPredictionAlgorithm,
TestAssociationAlgorithm,
TestFusionAlgorithm> fusionManager(env);
...
2) 使用模板替代继承和虚方法：
//factorization.h
template<typename ProbabilityDistributionType>
class Factorization
{
...
public:
ProbabilityDistributionType factorize();
private:
std::Vector<ProbabilityDistributionType> factors_m;
...
};
//factorization.cpp
template<>
CPD Factorization<CPD>::factorize()
{
for (auto & factor : factors_m)
{
factor.factorize();//This will call the factorize method of CPD
}
}
template<>
JointProbDistr Factorization<JointProbDistr>::factorize()
{
for (auto & factor : factors_m)
{
factor.factorize();//This will call the factorize method of JointProbDistr
}
}
不要使用像这样的东西：
//factorization.h
template<typename ProbabilityDistributionType>
class Factorization
{
...
public:
virtual ProbabilityDistributionType factorize() = 0;
private:
std::Vector<ProbabilityDistributionType> factors_m;
...
};
//cpd_factorization.h
class CPDFactorization : public Factorization<CPD>
{
...
public:
CPD factorize();//Implementing the parent's pure virtual method. This will call the factorize method of CPD
};
//jointprobdistr_factorization.h
class CPDFactorization : public Factorization<JointProbDistr>
{
...
public:
JointProbDistr factorize();//Implementing the parent's pure virtual method. This will call the factorize method of JointProbDistr
};