Question

您是否会以其他方式编写以下简单容器，或者它是完全合理的：

template <typename T, bool small_>
struct TransType
{
   typedef const T& param_type;
};

template <typename T>
struct TransType<T, true>
{
   typedef const T param_type;
};

template <class T>
class Container:public TransType<T,sizeof(T)<=sizeof(void*)> {
 public:
  param_type getVal(){
   return obj;
  }
  void setVal(param_type input){
   containment=input;
  }
 private:
  T containment;
};

Answer 1

我不会继承元函数。

Answer 2

查看Boost.CallTraits。即，boost::call_traits<T>::param_type。

您不应该要求客户端指定类型是否小，这是元函数的工作。也没有必要继承任何东西。

事实上，您现在的代码格式错误。因为param_type不是依赖类型，所以在不考虑基类的情况下完成查找;并且不会被发现。您需要使用基类明确限定它，添加using指令或重新定义它。

你最终想要：

template <typename T>
struct Container
{
    //typedef typename boost::call_traits<T>::param_type param_type;
    typedef typename TransType<T>::param_type param_type;

    // ...
};

人：

namespace detail
{
    template <typename T, bool small_>
    struct TransType
    {
       typedef const T& param_type;
    };

    template <typename T>
    struct TransType<T, true>
    {
       typedef const T param_type;
    };
}

template <typename T>
struct TransType<T>
{
   typedef detail::TransType<T, sizeof(T)<=sizeof(void*)> param_type;
};

现在条件是自动的，并且没有基类麻烦。

Answer 3

除了GMan关于需要以某种形式需要显式析构函数的评论之外，增加的复杂性是否会获得显着的性能？标准库似乎认为由用户在容器中存储适当的类型，以便在某些情况下复制不是瓶颈。

这个容器实现是否完全合理？

3 个答案: