Question

假设我们将下面的向量类缩短到最小值以展示问题。

template <typename T>
class VectorT : private std::vector<T>
{
  using vec = std::vector<T>;
public:
  using vec::operator[];
  using vec::push_back;
  using vec::at;
  using vec::emplace_back;

  // not sure if this is the beast way to check if my T is really a unique_ptr
  template<typename Q = T>
  typename Q::element_type* operator[](const size_t _Pos) const { return at(_Pos).get(); }
};

有没有办法检查T是否是unique_ptr，如果是，则添加运算符[]以返回unique_ptr :: element_type *。同时，正常的运算符[]也应该起作用。

VectorT<std::unique_ptr<int>> uptr_v; 
uptr_v.emplace_back(make_unique<int>(1));
//int* p1 = uptr_v[0]; // works fine if using vec::operator[]; is commented out
                       // then of course it wont work for the normal case
//std::cout << *p1;

VectorT<int*> v;
v.emplace_back(uptr_v[0].get());
int *p2 = v[0];
std::cout << *p2;

有什么方法可以实现这样的目标吗？

被修改：

我要求这个的原因是因为我可以说我的容器

class MyVec: public VectorT<std::unique_ptr<SomeClass>>

但我也可以有一个

class MyVecView: public VectorT<SomeClass*>

这两个类几乎都有相同的功能。所以我试图通过做像

这样的事情来避免重复

template<typename T>
void doSomething(VectorT<T>& vec)
{
    SomeClass* tmp = nullptr;

    for (size_t i = 0; i < vec.size(); ++i)
    {
        tmp = vec[i]; // this has to work though
        ....
    }
}

然后我当然可以

MyVec::doSomething(){doSomething(*this);}
MyVecView::doSomething(){doSomething(*this);}

这当然意味着operator[]必须适用于两种情况

Answer 1

这里的目标是只有一个operator[]。有多个operator[]的技术违反了DRY（不要自己重复），很难避免使用模板方法，如果实例化，其身体将无法编译（在严格阅读标准的情况下，可能导致您的代码格式不正确。）

所以我要做的就是模仿＆＃34;把东西变成指针＆＃34;像这样：

namespace details {
  template<class T>
  struct plain_ptr_t;

  //specialzation for T*
  template<class T>
  struct plain_ptr_t<T*> {
    T* operator()(T* t)const{return t;}
  };

  //specialzation for std::unique_ptr
  template<class T, class D>
  struct plain_ptr_t<std::unique_ptr<T,D>> {
    T* operator()(std::unique_ptr<T>const& t)const{return t.get();}
  };

  //specialzation for std::shared_ptr
  template<class T>
  struct plain_ptr_t<std::shared_ptr<T>> {
    T* operator()(std::shared_ptr<T>const& t)const{return t.get();}
  };
}

struct plain_ptr {
  template<class T>
  typename std::result_of< details::plain_ptr_t<T>( T const& ) >::type
  operator()( T const& t ) const {
    return details::plain_ptr_t<T>{}( t );
  }
};

现在plain_ptr是一个函子，它将智能指针映射到普通指针，并指向指针。

它拒绝那些没有指针的东西。如果你愿意，你可以改变它只是传递它们，但它需要一点小心。

然后我们使用它们来改善您的operator[]：

typename std::result_of< plain_ptr(typename vec::value_type const&)>::type
operator[](size_t pos) const {
  return plain_ptr{}(at(pos));
}

请注意，它不再是template。

live example

Answer 2

template<typename T> struct unique_ptr_type { };
template<typename T> struct unique_ptr_type<std::unique_ptr<T>> { using type = T; };

namespace detail {
    template<typename T> std::false_type is_unique_ptr(T const&);
    template<typename T> std::true_type is_unique_ptr(std::unique_ptr<T> const&);
}
template<typename T>
using is_unique_ptr = decltype(detail::is_unique_ptr(std::declval<T>()));

template<typename T>
class VectorT : std::vector<T> {
    using vec = std::vector<T>;

public:
    using vec::at;
    using vec::emplace_back;
    using vec::push_back;

    template<typename Q = T,
             typename std::enable_if<!is_unique_ptr<Q>::value>::type* = nullptr>
    Q& operator [](std::size_t pos) { return vec::operator[](pos); }
    template<typename Q = T,
             typename std::enable_if<!is_unique_ptr<Q>::value>::type* = nullptr>
    Q const& operator [](std::size_t pos) const { return vec::operator[](pos); }

    template<typename Q = T,
             typename U = typename unique_ptr_type<Q>::type>
    U* operator [](std::size_t pos) { return vec::operator[](pos).get(); }
    template<typename Q = T,
             typename U = typename unique_ptr_type<Q>::type>
    U const* operator [](std::size_t pos) const { return vec::operator[](pos).get(); }
};

Online Demo

SFINAE用于仅在operator[]为T时启用自定义std::unique_ptr<T>，否则仅启用std::vector<T>::operator[]。

Answer 3

如果你坚持使用普通指针，你可以编写类似

的内容

template<class T> auto plain_ptr(T* p) { return p; }
template<class T> auto plain_ptr(std::unique_ptr<T>& p) { return p.get(); }

然后再做

tmp = plain_ptr(vec[i]); // tmp will be SomeClass*

或者你可以拥有tmp local：

template<typename T>
void doSomething(VectorT<T>& vec)
{

    static_assert(std::is_same<T, SomeClass*>::value || 
      std::is_same<T, std::unique_ptr<SomeClass>>::value, 
      "doSomething expects vectors containing SomeClass!");

    for (std::size_t i = 0; i < vec.size(); ++i)
    {
        auto tmp = vec[i]; 
        // ... (*tmp).foo or tmp->foo ...
    }
    // or perhaps even
    for(auto&& tmp : vec)
    {
        // ... again (*tmp).foo or tmp->foo ...
    }

}

当Type为unique_ptr时，为向量添加operator []

3 个答案: