Question

假设我有一个拥有成员的主机类：

template<class p1, class p2>
struct host : public p1, public p2 {
 double member;
};

我希望在p1和p2中使用相同的成员：

struct p1 {
  void f1() { host::member+=1;} // this is incorrect but I'm looking for this behavior
};
struct p2 {
  void f2() {host::member*=2;}
};

有办法吗？

我能想到的一种方法是从另一个通过虚拟继承包含成员的类派生p1和p2，这会使事情变得复杂。

另一种方法是将成员传递给策略作为函数的参数。像这样的东西：

template<class p1, class p2>
struct host : public p1, public p2 {
 double member;
 void hf1() { p1::f1(member);}
 void hf2() { p2::f2(member);}
};
struct p1 {
  void f1(double m) { m+=1;} // this is incorrect but I'm looking for this behavior
};
struct p2 {
  void f2(double m) {m*=2;}
};

另一个想法是使用CRTP并从主机的策略和策略派生主机，以便可以使用using访问该成员，但这是不可能的。

更新（1）

我尝试使用CRTP

template<class p1, class p2>
struct host : public p1, public p2 {
 double member;
};


template<host_type>
struct p1 : public host_type { // error: invalid use of incomplete type 'struct host<p1,p2>'
  void f1() { host_type::member+=1;}
};
template<host_type>
struct p2 : public host_type<p1,p2> { // error: expected template-name before '<' token
  void f2() {host_type::member*=2;}
};

Answer 1

这是一种在没有策略继承自主机的情况下执行CRTP的方法

template <typename DerivedT>
struct p1
{
    DerivedT&       derived()       { return *static_cast<DerivedT*>(this);       }
    const DerivedT& derived() const { return *static_cast<const DerivedT*>(this); }

    void f1()
    {
        derived().member += 1;
    }
};

template <typename DerivedT>
struct p2
{
    DerivedT&       derived()       { return *static_cast<DerivedT*>(this);       }
    const DerivedT& derived() const { return *static_cast<const DerivedT*>(this); }

    void f2()
    {
        derived().member *= 2;
    }
};

struct host : public p1<host>, public p2<host>
{
     double member;
};

如何在政策之间分享会员？

1 个答案: