-3

受 boost::operators 的启发，我认为 Barton-Nackman 成语可以用来从琐碎的成员方法中实现。

以下是我尝试过的（不编译）

template<typename T>
class impl_get_set {
    typename T::storage_type get() const {
        return static_cast<const T *>(this)->data_;
    }

    void set(typename T::storage_type d) {
        *static_cast<T *>(this)->data_ = d;
    }
};

struct A : public impl_get_set<A> {
    typedef int storage_type;
    storage_type data_;
};

struct B : public impl_get_set<B> {
    typedef double storage_type;
    storage_type data_;
};

由于这无法编译，因此显然我做错了。我的问题是，这可以做到吗，如果可以，怎么做？

4

2 回答 2

3

使用 CRTP 时，在设计基础时必须小心，即impl_get_set在这种情况下。当派生类实例化基特化时，例如用 完成A: public impl_get_set<A>，A该类仍然是不完整的。

但是，在成员函数声明中impl_get_set使用的定义。typename T::storage_type这种使用需要一个完整的T. 解决这个问题的 C++03 方法是将 CRTP 基可能需要的任何关联类型作为类模板参数的一部分：

template<typename Derived, typename StorageType>
struct get_set {
    typedef StorageType storage_type;

    // It's possible to define those inline as before where
    // Derived will be complete in the body -- which is why
    // CRTP is possible at all in the first place
    storage_type get() const;
    void set(storage_type s);

    // Convenience for clients:
protected:
    typedef get_set get_set_base;
};

struct A: get_set<A, int> {
    // Member type is inherited
    storage_type data;
};

template<typename T>
struct B: get_set<B<T>, double> {
    // Incorrect, storage_type is dependent
    // storage_type data;

    // First possibility, storage_type is
    // still inherited although dependent
    // typename B::storage_type data;

    // Second possibility, convenient if
    // storage_type is used multiple times
    using typename B::get_set_base::storage_type;
    storage_type data;
    void foo(storage_type s);
};

boost::iterator_facade是 Boost.Iterator 编写的 C++03 风格的 CRTP 包装器的一个很好的例子。

C++11 提供了另一种编写 CRTP 基础的方法，这部分归功于函数模板的默认模板参数。通过使派生类参数再次依赖，我们可以像完成一样使用它——它只会在 CRTP 基特化的成员函数模板被实例化时检查，一旦它完成，而不是在 CRTP 基特化时本身就是：

// Identity metafunction that accepts any dummy additional
// parameters
template<typename T, typename... Dependent>
struct depend_on { using type = T; };

// DependOn<T, D> is the same as using T directly, except that
// it possibly is dependent on D
template<typename t, typename... D>
using DependOn = typename depend_on<T, D...>::type;

template<typename Derived>
struct get_set {
    template<
        // Dummy parameter to force dependent type
        typename D = void
        , typename Storage = typename DependOn<Derived, D>::storage_type
     >
     Storage get() const
     {
         // Nothing to change, Derived still complete here
     }
};

实际上，对于您的示例，get_set可以说不需要关心成员类型是否存在：

// std::declval is from <utility>

template<
    typename D = void
    , typename Self = DependOn<Derived, D>
>
auto get() const
-> decltype( std::declval<Self const&>().data )
{ return static_cast<Derived const&>(*this).data; }

这个实现get与您自己的语义略有不同，因为它返回一个引用，data但这是故意的。

于 2013-06-12T10:59:00.603 回答
0

我能想到的最好的办法是你遇到了鸡/蛋的问题。

struct A 使用 impl_get_set 作为基础，强制实例化。但此时 A 是不完整的，其内容尚不可用。因此 T::storage_type 无法解决任何问题。

我发现的唯一解决方法是为 impl_get_set 设置另一个模板参数并从上面传递它。所以往相反的方向走：

template<typename T, typename ST>
class impl_get_set {
public:  
    typedef ST storage_type;
    storage_type get() const {
        return static_cast<const T *>(this)->data_;
    }

    void set(storage_type d) {
        *static_cast<T *>(this)->data_ = d;
    }
};

struct A : public impl_get_set<A, int> {
    storage_type data_;
};

（A 目前没有在基地使用，我把它留给可能的其他计划）

于 2013-06-12T10:45:13.080 回答