class AlarmData_b01
{
    bool isAlarm;
    bool isCountActivate;
};

class MeintenanceData_b01
{
    bool isMeintenance;
    bool isCountActivate;
};

class MeintenanceData_f32
{
    unsigned short Id;
    unsigned long Time;
    float Rate;
};

AlarmData_b01       *AlarmData_b01_Alarm1_ptr       = InputBits<AlarmData_b01>::Add();
AlarmData_b01       *AlarmData_b01_Alarm2_ptr       = InputBits<AlarmData_b01>::Add();

MeintenanceData_b01 *AlarmData_b01_Meintenance1_ptr = InputBits<MeintenanceData_b01>::Add();
MeintenanceData_b01 *AlarmData_b01_Meintenance2_ptr = InputBits<MeintenanceData_b01>::Add();

MeintenanceData_f32 *AlarmData_f32_Meintenance1_ptr = InputRegs<MeintenanceData_f32>::Add();
MeintenanceData_f32 *AlarmData_f32_Meintenance2_ptr = InputRegs<MeintenanceData_f32>::Add();

InputBits<AlarmData_b01>::AddresSet(100);
InputBits<MeintenanceData_b01>::AddresSet(110);

InputRegs<MeintenanceData_f32>::AddresSet(100);

template <typename T_DataType>
class ModBusTables
{
    protected:

    static unsigned short   Addres;
    static unsigned short AreaSize;
    T_DataType *AreaData_ptr;

    ModBusTables();

    public:

    static void AddresSet(unsigned short ModBusAddres);
};

static unsigned short Addres        - Адрес области в таблице протокола Модбас
static unsigned short AreaSize      - Размер объектов в области
T_DataType            *AreaData_ptr - Тип для приведения указателя.

template <class T_DataStruct, class Specialization> class ModBusTable;

template <class T_DataStruct, typename T_DataType, template<typename> class TT_Table>
class ModBusTable<T_DataStruct, TT_Table<T_DataType> > : public TT_Table<T_DataType>
{
    private:

    T_DataStruct AreaData;

    public:

    static T_DataStruct *Add()
    {
        ModBusTable *ModBusArea_ptr = new ModBusTable();

        T_DataStruct *Instance_Ptr = &ModBusArea_ptr->AreaData;

        ModBusTable<T_DataStruct, TT_Table<T_DataType> >::AreaSize  = sizeof(ModBusArea_ptr->AreaData);
        ModBusArea_ptr->AreaData_ptr = (T_DataType *)Instance_Ptr;

        return Instance_Ptr;
    }
};

template <class T> class InputBits:     public ModBusTable<T, ModBusTables<bool> >  {};
template <class T> class InputRegs:     public ModBusTable<T, ModBusTables<unsigned short> > {};
template <class T> class OutputBits:    public ModBusTable<T, ModBusTables<bool> > {};
template <class T> class OutputRegs:    public ModBusTable<T, ModBusTables<unsigned short> > {};

InputBits<AlarmData_b01> и InputBits<MeintenanceData_b01>?

InputBits<AlarmData>::Add()

template<class A, class B>
struct Base{};

template<class A>
using WrapperFirst = Base<A, int>;

template<class A>
using WrapperSecond = Base<A, double>;

int main() {
    WrapperFirst<int> a;
    WrapperSecond<int> b;

    return 0;
}

template<class A, class B>
struct Base{};

template<class A>
struct Wrapper
{
    typedef Base<A, int> first;
    typedef Base<A, double> second;
};

int main() {
    Wrapper<int>::first a;
    Wrapper<int>::second b;

    return 0;
}