Reduce code duplication in class template specialization (array)

Question

How to reduce code duplication of a class that is template specialized?

I am trying to create a class (MyArray) that acts like std::vector but receives raw-pointer as parameter in some functions.

Here is a simplified version of it :-

template<class T> class MyArray{
    T database[10];
    public: T& get(int index){return database[index];}
    void set(int index, T t){
        database[index]=t;
    }
};
template<class T> class MyArray<std::unique_ptr<T>>{
    T* database[10];
    public: T*& get(int index){return database[index];}
    void set(int index, std::unique_ptr<T> t){
        T* tmp=t.release();
        database[index]=tmp;  
    }
};

Here is a test:-

class B{};
int main() {
    MyArray<B>   test1;
    MyArray<B*>  test2;
    MyArray<std::unique_ptr<B>> test3;
    test3.set(2,std::make_unique<B>()));
    return 0;
}

Question: Please demonstrate an elegant way to reduce the above code duplication in MyArray.

A solution that I wished for may look like :-

template<class T> class MyArray{
    using U = if(T=std::uniquePtr<X>){X*}else{T};
    U database[10];
    public: U& get(int index){return database[index];}
    void set(int index, T t){
        U u = convert(t);//<-- some special function
        database[index]=u;
    }
};

There might be some memory leak / corruption. For simplicity, please overlook it.
I just want an idea/rough guide. (no need to provide a full run-able code, but I don't mind)

In real life, there are 20+ function in MyArray and I wish to do the same refactoring for many classes.

Edit: I have (minor) edited some code and tag. Thank AndyG and Jarod42.

This code is not C++11... `std::make_unique` is a C++14 feature. Perhaps you're using a version of Visual Studio, 2013? — AndyG, Apr 12 '17 at 11:25
@Jarod42 Thank. That is new knowledge for me. I have just noticed that my code also contained other errors. I will try to fix some of them. — javaLover, Apr 12 '17 at 11:32

score 3 · Answer 1 · answered Apr 12 '17 at 10:17

Maybe can you delegate the implementation details to a struct you provide to your class, and you specialize this struct, not MyArray:

template <typename T>
struct Policy {
  using type = T;
  static type convert(T t) { ... }
};

template <typename T>
struct Policy<std::unique_ptr<T>> {
  using type = T*;
  static type convert(T t) { ... }
};

template <typename T, typename P = Policy<T>>
class MyArray
{
  using type = typename P::type;

  void set(int index, T t) { type result = P::convert(t); }
};

score 1 · Answer 2 · answered Apr 12 '17 at 11:36

You might think about using a common base class for the common functionality:

template<class T>
class Base{
    protected:
    T database[10];
    public:
    T& get(int index){return database[index];} 
};

template<class T> 
class MyArray : public Base<T>{
    public:
    void set(int index, T t){
        this->database[index]=t;
    }
};

template<class T> 
class MyArray<std::unique_ptr<T>> : public Base<T*>
{
    public:
    void set(int index, std::unique_ptr<T>&& t){
        T* tmp=t.release();
        this->database[index]=tmp;   //a little different
    }
};

Demo

It is funny that I just notices you change the font size of "Demo". XD — javaLover, Apr 12 '17 at 11:39

Reduce code duplication in class template specialization (array)

2 Answers2

Demo