重构 c++基于模板类型的模板类

Question

给定 Foo 类，

template <typename T>
class Foo
{
public:

  ...other methods..

  void bar()
  {
    ...
    m_impl.doSomething();
    ...
  }

  void fun()
  {
    ...
    m_impl.doSomethingElse();
    ...
  }

  void fubar()
  {
    ...
  }

private:
  T m_impl;
};

我想满足 T 是 boost::shared_ptr 的情况。 在这种情况下，对 Foo 类的唯一更改是它应该调用，

m_impl->doSomething();

而不是

m_impl.doSomething();

我最终在同一个标​​头中定义 FooPtr

template <typename T>
class FooPtr
{
public:
  ...other methods..

  void bar()
  {
    ...
    m_pImpl->doSomething();
    ...
  }

  void fun()
  {
    ...
    m_pImpl->doSomethingElse();
    ...
  }

  void fubar()
  {
    ...
  }

private:
  boost::shared_ptr<T> m_pImpl;
};

现在，虽然该方法适用于我想与 Foo 一起使用的所有类， 问题是我有很多重复的代码以及任何更改 我对 Foo 进行了操作，我还必须对 FooPtr 进行操作。

我该如何重构代码？例如，有什么方法可以在编译时确定 T 是否属于 boost::shared_ptr 类型，然后专门化 bar 和 fun 方法来调用 ->操作员？

编辑： 感谢到目前为止所有的答案！我只需要一些时间来完成所有这些工作，看看哪种解决方案最适合我们的软件。

编辑2： @Matthieu：这是我正在使用的测试代码

class FooImpl
{
public:
  void doIt()
  {
    cout << "A" << std::endl;
  }
};

int _tmain(int argc, _TCHAR* argv[])
{
  Foo<FooImpl> foo;
  foo.doSomething();
  return 0;
}

Answer 1

Sylvain 编写了一个 DRY 解决方案，但我不喜欢滥用继承。

使用包装类来统一接口很容易，特别是因为指针语义工作得很好！

namespace details {
  template <typename T>
  struct FooDeducer {
    typedef boost::optional<T> type;
  };

  template <typename T>
  struct FooDeducer< T* > {
    typedef T* type;
  };

  template <typename T>
  struct FooDeducer< boost::shared_ptr<T> > {
    typedef boost::shared_ptr<T> type;
  };
} // namespace details

template <typename T>
class Foo {
public:
  // methods
  void doSomething() { impl->doIt(); }

private:
  typedef typename details::FooDeducer<T>::type Type;
  Type impl;
};

在这里，依靠提供OptionalPointee语义的boost::Optional，我们几乎得到了与指针相同的行为。

但我想强调的一点是复制行为的差异。 boost::Optional 提供深度复制。

Answer 2

class A
{
public:
    void doSomething() {}
};
template <typename T>
class Foo
{
public:
  void bar()
  {
    Impl(m_impl).doSomething();
  }

private:
    template<typename P>
    P& Impl(P* e)
    {
        return *e;
    }
    template<typename P>
    P& Impl(std::shared_ptr<P> e)
    {
        return *e;
    }
    template<typename P>
    P& Impl(P& e)
    {
        return e;
    }
  T m_impl;
};

Answer 3

您可以编写一个 caller 类模板，其工作是使用语法 obj.f() 或 obj->f()< 来调用函数/code>，基于 obj 的类型。

下面是一个演示此方法的小示例：

template<typename T>
struct caller
{
    static void call(T &obj) {  obj.f(); } //uses obj.f() syntax
};

template<typename T>
struct caller<T*>
{
    static void call(T* obj) {  obj->f(); } //uses obj->f() syntax
};

此示例类使用了此 caller 类模板：

template<typename T>
struct X
{
   T obj;
   X(T o) : obj(o) {}
   void h()
   {
        caller<T>::call(obj); //this selects the appropriate syntax!
   }
};

请参阅 ideone 上的在线运行演示：http://www.ideone.com/H18n7

--

编辑：

这更加通用。在这里您甚至可以在 caller 中传递您想要调用的函数。现在，caller 并未与要调用的函数进行硬编码！

http://www.ideone.com/83H52

Answer 4

我真的怀疑你是否应该在这里使用模板。您的模板参数具有非常清晰的接口，因此看起来您应该只使用抽象基类。

您真的需要一个实例吗？如果您确实需要更改对象的表示方式，则应将其作为单独的练习来完成，而不是使用它的模板的一部分。

Answer 5

您可以引入另一个中间模板类，如下所示：

template < typename T >
class FooBase
{
private:
    T m_impl;

protected:
    T& impl() { return m_impl; }
};

template < typename T >
class FooBase< boost::shared_ptr< T > >
{
private:
    boost::shared_ptr< T > m_impl;

protected:
    T& impl() { return *(m_impl.operator ->()); }
};

template < typename T >
class Foo : protected FooBase< T >
{
public:
    void bar()
    {
        impl().DoSomething();
    }
};

现在，您只需编写 Foo 类一次。您可以通过对 FooBase 进行部分特化来将其专门化为其他智能指针类型。

编辑：您还可以使用组合，而不是在 Foo 和 FooBase 之间建立继承关系（在这种情况下，我可能会将其重命名为 FooHelper > 或类似的东西）。

template < typename T >
class FooHelper
{
private:
    T m_impl;

public:
    T& impl() { return m_impl; }
};

template < typename T >
class FooHelper< boost::shared_ptr< T > >
{
private:
    boost::shared_ptr< T > m_impl;

public:
    T& impl() { return *(m_impl.operator ->()); }
};

template < typename T >
class Foo
{
private:
    FooHelper< T > m_helper;

public:
    void bar()
    {
        m_helper.impl().DoSomething();
    }
};

Answer 6

您可以使用部分专业化。

template <typename T>
class Foo
{
public:
  //...
};

template<typename T> class Foo<boost::shared_ptr<T>> {
  //... implement specialization here
};