C++ c++；带参数的模板策略

我是新来的。我正在创建一个包含策略的类，策略是：

template <typename T,
          typename P1 = Policy1<T>,
          typename P2 = Policy2<T> >

{
    ...
}

模板
{
...
}

我的问题是有些策略有参数，当它们在编译时就可以了

template <typename T,
          typename P1 = Policy1<T, size_t N>,
          typename P2 = Policy2<T> >

模板

---

但是当它们运行时，我不确定提供策略类对象的最佳方式是什么。。。或者这不再是一种策略模式？

模板中的策略用于在编译时自定义类，而不是在运行时自定义类（策略塑造实例的类型，并且您不能在C++中在运行时决定类型）

---

运行时的并行通常称为“依赖项注入”，您可以通过传递实例将向其委派操作的已构造对象来完成此操作。

您可以为策略创建一个工厂：）编辑请参见下面添加的内容

或者您可以像标准库那样执行以下操作：

#include <string>

struct DummyPolicy { };

template <typename>
struct Policy1 { Policy1(int, std::string) { } };

template <typename T,
          typename P1 = Policy1<T> >
struct X 
{
     X(P1 p1 = {}) : _policy1(std::move(p1)) { }

   private:
     P1 _policy1;
};

#包括
结构DummyPolicy{}；
模板
结构Policy1{Policy1（int，std:：string）{}；
模板
结构X
{
X（P1={}）：_policy1（std:：move（P1））{}
私人：
P1_政策1；
};

并使用它

int main()
{
     X<int, DummyPolicy> no_questions_asked;
     X<int> use_params({42, "hello world"});
}

intmain（）
{
X没有被问到任何问题；
X使用_参数（{42，“hello world”}）；
}

使用C++03或显式构造函数时，显然会详细说明：

     X<int> use_params(Policy1<int>(42, "hello world"));

X使用参数（策略1（42，“你好世界”）；

查看它

---

更新：工厂 以下是显示工厂方法的更新：

#include <string>

namespace details
{
    template <typename PolicyImpl>
        struct PolicyFactory
        {
            static PolicyImpl Create() {
                return {};
            }
        };
}

template <typename>
struct Policy2 { Policy2(double) { } };

template <typename T,
          typename P1 = Policy2<T> >
struct X 
{
    X()      : _policy1(details::PolicyFactory<P1>::Create()) {}
    X(P1 p1) : _policy1(std::move(p1)) { }

  private:
    P1 _policy1;
};

///// supply a factor, possibly local to a TU:

namespace details
{
    template <typename T>
        struct PolicyFactory<Policy2<T> > {
            static Policy2<T> Create() { 
                return Policy2<T>(3.14);
            }
        };
}

int main()
{
     // with a factory:
     X<std::string, Policy2<std::string> > no_params_because_of_factory;
}

#包括
命名空间详细信息
{
模板
结构策略工厂
{
静态PolicyImpl Create（）{
返回{}；
}
};
}
模板
结构Policy2{Policy2（double）{}；
模板
结构X
{
X（）：_policy1（详细信息：：PolicyFactory：：创建（））{}
X（P1）：_policy1（std:：move（P1））{
私人：
P1_政策1；
};
/////提供一个因子，可能是TU的局部因子：
命名空间详细信息
{
模板
结构策略工厂{
静态策略2 Create（）{
退货政策2（3.14）；
}
};
}
int main（）
{
//对于工厂：
X由于工厂的原因而没有参数；
}

看到了吗*

注意

• 我更喜欢构造函数传入方法
• 从技术上讲，这家工厂是一个典型的阶级

---

给我们一个示例，说明您希望如何在运行时执行此操作。标准库通过在构造函数中接受初始值设定项来解决此问题。例如，对于自定义比较器或分配器。假设策略类有一个接受参数的构造函数，您将对象传递给class@gsf那么你已经知道怎么做了…？@sehe你能详细说明一下吗？看吧@gsf添加了工厂的完整性理念。谢谢，似乎是合乎逻辑的，我只是不确定这是最好的方式