Exclude class member by specialization - c++

Question

I have base class template, on that I'm making some another class, which are specialized versions of my base class. I know how to exclude some methods from particular specialization case, but is there any possibility to make that for class's members? Example code, of what I want to achieve:
template<typename T>
class Base {
This variable exists only when T==integer VARIABLE;
}
template <Typename T>
WithVariable = using Base<int>;
template <Typename T>
Without = using Base<double>
I think that I should use std::enable in some way, but using it makes possible to make VARIABLE of type "void", when I don't want that variable. That is still not the situation I want to achieve.

Answer 1

Can you just specialise the class without the unwanted members?
template <typename T>
class Base {
public:
T t;
};
template <>
class Base<int> {
};
int main() {
Base<int> foo;
foo.t = 42; // Error: no member named 't' in 'Base<int>'
}

Answer 2

One possible way to do this is to inherit conditionally. Take a look:
struct BaseWithVariable {
int n {42};
};
struct BaseNoVariable {};
template <typename T>
struct Base : std::conditional<std::is_same<T, int>::value, BaseWithVariable, BaseNoVariable>::type {};
and usage:
Base<int> b {};
Base<double> d {};
std::cout << b.n << std::endl;
std::cout << d.n << std::endl; // error
You can also write an explicit specialization for your type, but if you have a group of types (like integers or type derived from specific base) which should have different members than general type, this solution can be helpful.

Answer 3

You can use a base for base that use SFINAE
#include <type_traits>
template <typename, typename = void>
struct base_of_base;
template <typename T>
struct base_of_base<T, typename std::enable_if<std::is_integral<T>::value>::type>
{ int var; };
template <typename T>
struct base_of_base<T, typename std::enable_if<!std::is_integral<T>::value>::type>
{ };
template <typename T>
class base : public base_of_base<T>
{ };
int main()
{
base<int> bi;
base<long> bl;
base<float> bf;
base<double> bd;
bi.var = 1; // OK
bl.var = 1; // OK
// bf.var = 1; // error: ‘class base<float>’ has no member named ‘var’
// bd.var = 1; // error: ‘class base<double>’ has no member named ‘var’
}

Answer 4

How about deleteing the functions from specialisations of the class?
template <typename T>
class Base {
public:
void notUseful();
};
template<typename T>
void Base<T>::notUseful(){
std::cout << "not useful" << std::endl;
return;
}
template <>
void Base<int>::notUseful() = delete;