Adapter of collection - omit T that depends on underlying collection - c++

Question

I am trying to create an adapter of a custom collection MyArray<T>.
For simplicity, the adapter Adapter does only one thing : cast the return result of MyArray<T>::get.
(In real case, MyArray and Adapter are very complex database manipulators.)
Version 1
Here is the first version, it works. (demo)
#include <iostream>
using namespace std;
template<class T>class MyArray{
public: T* database[20];
public: T* get(int index){return database[index];} //<-important
public: void set(int index,T* t){database[index]=t;}
};
template<class T,class T2> class Adapter{
public: MyArray<T>* underlying;
public: void setUnderlying(MyArray<T>* pUnder){underlying=pUnder;}
public: T2* get(int index){return static_cast<T2*>(underlying->get(index));}
//^ "Adapter::get()" is encapsulating "MyArray::get()"
};
class B{};
class C:public B{};
class D:public C{};
int main() {
MyArray<B> bs;
bs.set(0,new C()); //some can be new D()
//About the Adapter<C>, user is the one who sure that "bs" elements are "C*"-castable.
Adapter<B,C> cs; //<-- #1 need improve
cs.setUnderlying(&bs); //<-- assign MyArray* to adapter
C* c=cs.get(0);
return 0;
}
Version 2
Then, I want to sacrifice performance for readability and convenience. (#1)
Objective: Reduce amounts of template parameters of from 2 (Adapter<B,C>) to 1 (Adapter<C>).
Here is my work so far. It is compilable but should crash in some cases:-
class MyArrayBase{ //<--- new class
public: virtual void* get(int index)=0;
};
template<class T>class MyArray : public MyArrayBase{
public: T* database[20];
public: T* get(int index){return database[index];}
public: void set(int index,T* t){database[index]=t;}
};
template<class T2> class Adapter{
public: MyArrayBase* underlying; //<--- more abstraction
public: void setUnderlying(MyArrayBase* pUnder){underlying=pUnder;}
public: T2* get(int index){return static_cast<T2*>(underlying->get(index));} //#wrong
};
class B{};
class C:public B{};
int main() {
MyArray<B> bs;
bs.set(0,new C());
Adapter<C> cs; //<--- Yes! 1 template argument.
cs.setUnderlying(&bs);
C* c=cs.get(0);
std::cout<<"hi"<<std::endl;
return 0;
}
The reason that it is wrong :-
At the #wrong, void* (underlying B*) is static_cast to C*.
Here is the demo shows that it is wrong. (print 0 instead of 5)
Question
How to improve my first version of code to make Adapter have less template parameter?
Criteria :-
Don't use function pointer.
I feel it is possible with function pointer or std::function, but it seems to be a hack.
I also want to know if it is possible without using it.
Overhead should not be (roughly) worse than a single virtual calling (v-table) as in Version 2.
A single instance of Adapter<C>::setUnderlying must be able to accept any MyArray<X>* when it makes sense to call static_cast<C*>(X*).
MyArray and Adapter are library class. It doesn't have any knowledge about the type T or T2.
For example, I can't replace void* in class MyArrayBase with B*.
Light criteria :-
I prefer a solution using virtual function.
It would be ideal if there is no virtual-cost, but I don't think it is possible.

Answer 1

You can use some kind of wrapper that wraps the container, typically:
// Here T = T2, you want a virtual function that already give you the right type
template <typename T>
class Wrapper {
public:
virtual T* get(int index) const = 0;
};
// The real wrapper: It can give you T2 (To) but keep information
// about the original type since it is templated on Container
template <class To, class Container>
class WrapperContainer: public Wrapper<To> {
Container *cont_;
public:
WrapperContainer(Container *cont) : cont_(cont) { }
virtual To* get(int index) const override {
return static_cast<To*>(cont_->get(index));
}
};
The wrapper is the middle-guy between your Adapter that only knows the To type (the type you want to convert to) and your MyArray that only knows the From type (the type you want to convert from) - The WrapperContainer knows both, so it can safely convert from one to the other when it is possible.
The final Adapter:
template<class T2>
class Adapter {
std::unique_ptr<Wrapper<T2>> w_;
public:
template <typename Container>
void setUnderlying(Container *cont) {
w_ = std::unique_ptr<Wrapper<T2>>(new WrapperContainer<T2, Container>(cont));
}
T2* get(int index) {
return w_->get(index);
}
};
Using this you do not want a base class for MyArray since you need setUnderlying to deduce the type B from MyArray<B>:
// No more need for a base class
template<class T>
class MyArray {
T* database[20];
public:
T* get(int index){return database[index];}
void set(int index,T* t){database[index]=t;}
};
The important change from your code is actually this line:
return static_cast<To*>(cont_->get(index));
The type of cont_->get(index) is B* (in this example) and not void*, which makes the conversion work. This also prevents using setUnderlying with array of non-compatible type (try to uncomment the line cs.setUnderlying(&as); in the code below).
You can test it here: http://coliru.stacked-crooked.com/a/116305ec5f18b673