#include <iostream>
#include <cstddef>
#include <type_traits>
#include <memory>
#include <vector>
using namespace std;
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 );
}
};
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;
typename std::result_of< plain_ptr(typename vec::value_type const&)>::type
operator[](const size_t _Pos) const {
return plain_ptr{}(at(_Pos));
}
};
int main() {
VectorT<std::unique_ptr<int>> uptr_v;
uptr_v.emplace_back(std::make_unique<int>(1));
int* p1 = uptr_v[0];
std::cout << *p1;
VectorT<int*> v;
v.emplace_back(p1);
int *p2 = v[0];
std::cout << *p2;
// your code goes here
return 0;
}
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