c++ enable, disable class member functions? - c++11

Question

Is it possible to enable, disable class member functions?
Situation:
I have a class with 2 types. Each Type has a own constructor. One Type need a function which must not have the other Type.
Example:
class A {
enum struct TypeEnum : int {
TYPE_1 = 1,
TYPE_2 = 2
};
const TypeEnum type;
int x;
A(void) : type(TypeEnum::TYPE_1) { }
A(int _x) : type(TypeEnum::TYPE_2) {
x = _x;
}
// function only for Type 2
void A::operator += (const int& n) {
x = x + n;
}
};
int main() {
A test1 = new A();
A test2 = new A(1);
test1 += 5; // compiler error should be here
test2 += 5; // OK
return 0;
}
Is where something possible like this:
class A {
enum struct TypeEnum : int {
TYPE_1 = 1,
TYPE_2 = 2
};
const TypeEnum type;
int x;
A(void) : type(TypeEnum::TYPE_1) { }
A(int _x) : type(TypeEnum::TYPE_2) {
x = _x;
}
// Is somethig like this realy impossible
void A::operator += (const int& n) -> enable_if(type == TypeEnum::Type2) { // if not compile error
x = x + n;
}
};

Answer 1

You can use specialization:
enum struct TypeEnum : int {
TYPE_1 = 1,
TYPE_2 = 2
};
template<TypeEnum Type>
class A;
template<>
class A<TypeEnum::TYPE_1>
{
public:
A(void) { }
};
template<>
class A<TypeEnum::TYPE_2>
{
public:
A(int _x) {
x = _x;
}
int x;
void operator += (const int& n) {
x = x + n;
}
};
int main() {
A<TypeEnum::TYPE_1> test1;
A<TypeEnum::TYPE_2> test2{1};
test1 += 5; // compiler error should be here
test2 += 5; // OK
return 0;
}

Answer 2

Maybe following may help:
class A {
public:
explicit A(TypeEnum type) : type(type) {}
virtual ~A() {}
protected:
enum struct TypeEnum : int {
TYPE_1 = 1,
TYPE_2 = 2
};
const TypeEnum type;
};
class B : public A{
public:
B() : A(TYPE_1) {}
};
class C : public A{
public:
explicit C(int x) : A(TYPE_2), x(x) {}
C& operator += (int n) { x = x + n; }
private:
int x;
};
inheritance is here to reflect your case with a common type. it is not required else.
A thing you can do anyway:
B make_A() { return B{}; }
C make_A(int x) { return C{x}; }
int main() {
auto test1 = make_A(); // B
auto test2 = make_A(1); // C
test1 += 5; // compiler error should be here
test2 += 5; // OK
return 0;
}

Answer 3

Strange that you didn't get compilation error here:
// function only for Type 2
void A::operator += (const int& n) {
x = x + n;
}
I thought you wanted something like:
// function only for Type 2
A& operator += (int n) {
x = x + n;
return *this;
}
Answering on your question - C++ doesn't work like this. Nevertheless you can implement something similar with templates but I suggest not to do it unless it's just a test program.