template specialization for constructor of a parent class

Question

I got a BaseType which is templated and want to inheritance it with an ArrayItem class. Since i want to use them as stencil for memory i want the ArrayItem class to know which type we have. So i'd like to specialize the constructor for some of the Template values for example long long.

    template<typename T>
    class ArrayItem : public BaseType<T>
    {
    public:
        inline ArrayItem(T& t);
        inline ETypes getType();
    private:
        ETypes m_type;
    };

And the hpp should look like this:

template <typename T>
ArrayItem<T>::ArrayItem (T& t): BaseType(t)
{
}

template <>
ArrayItem<long long>::ArrayItem(long long& t) : BaseType<long long>(t) // this
{
    m_type = INT;
}


template<typename T>
inline ETypes ArrayItem<T>::getType()
{
    return m_type;
}

But the how do i do this specialization here?

---

enum ETypes
{
    INT,
    BOOL,
    OBJECT,
    ARRAY,
    DOUBLE,
    STRING
};

template <typename T>
class BaseType
{
public:
    BaseType();
    explicit BaseType(T& t);

protected:
        union DataUnion
        {
            T data;
            size_t size; //to make it at least 64bit
        explicit DataUnion(T& t);
        } m_data;
};

template <typename T>
BaseType<T>::DataUnion::DataUnion(T& t)
{
    this->data = t;
}

template <typename T>
BaseType<T>::BaseType(T& t) : m_data(t) {}

template<typename T>
class ArrayItem : public BaseType<T>
{
public:
    explicit inline ArrayItem(T& t);
    inline ETypes getType();
private:
    ETypes m_type;
};

template <typename T>
ArrayItem<T>::ArrayItem (T& t): BaseType<T>(t)
{
}

template <>
ArrayItem<long long>::ArrayItem(long long& t) : BaseType<long long>(t) // this
{
    m_type = INT;
}

template<typename T>
inline ETypes ArrayItem<T>::getType()
{
    return m_type;
}

int main()
{
long long somenumber = 1234;
  ArrayItem<long long> item(somenumber);
  if(item.getType() == INT)
    std::cout<< "inttype";
//after this we can stancil the ptr to a
//BaseType<long long> since we know it's a long here
}

Answer 1

What you have looks right to me, outside of not providing the template arguments to BaseType for the typical case.

Here's a simple demo:

#include <iostream>

template <typename T>
struct B { };

template <typename T>
struct D : B<T> {
    D(T );
};

template <typename T>
D<T>::D(T )
    : B<T>()
{
    std::cout << "def\n";
}

template <>
D<long>::D(long ) 
    : B<long>()
{
    std::cout << "hi\n";
}

int main()
{
    D<int> i(4);  // prints def
    D<long> l(5); // prints hi
}