I'd strongly suggest against using exception for this, it's error-prone, and not what they are meant for.
One of the issue would be extensibility. Using exception, say you add one type, you have to be sure you've add it to your try-catch statement. Moreover, it's a bad habit, because it break the usual code flow. (say you add something after g(), it will never be called.
Another issue is that if there are actual exception, you would have logic mixed with error handling in the same catch block, which would then become harder to read. Or you might have code throwing an exception while an exception was already thrown, which would stop the execution altogether.
If you want to use union, you could use std::variant, or use a switch statement on your enum (which is better than using ifs one after the other.)
However, in C++, and most Object Oriented language, there is a better way to achieve what you want here, using inheritance:
class C{ int i ; public : C(int i):i(i){cout << "C(" << i << ")\n";} void display() const { cout << "#C(" << i << ")\n"; } };
class D{ int i ; public : D(int i):i(i){cout << "D(" << i << ")\n";} void display() const { cout << "#D(" << i << ")\n"; } };
class E{ int i ; public : E(int i):i(i){cout << "E(" << i << ")\n";} void display() const { cout << "#E(" << i << ")\n"; } };
In your code here, we can see that all these classes have a common interface (understand here, a common "shape", they all have a void display() const method.
We could generalize all these class as the "same" as this one (at least if the logic inside their method is ignored)
class displayable {
public:
void display() const;
};
Now, this will be a common "type". However, we want all three class to be able to either implement, or override the function display. let's change this:
class i_displayable {
public:
virtual ~i_displayable(){}
virtual void display() const = 0;
};
class displayable {
public:
virtual ~displayable() {}
virtual void display() { std::cout << "displayable with default implementation" << std::endl;}
};
So, what is the differences between those two:
i_displayable declare display as a pure virtual member. What that mean is that any class inheriting from i_displayable will have to implement display()
displayable declare display() as a virtual member, and provide an implementation. This will allow inheriting class to override the function.
I'll get to why both declare a virtual destructor in an instant.
Let's rewrite class C for now.
class C : public displayable {
int i;
public:
C(int i): i(i) { std::cout << "C(" << i >> ")" << std::endl;}
virtual ~C(){}
void display() const override {
std::cout << "#C(" << i << ")" << std::endl;
}
}
So, we've override the display function (the override keyword is optionnal), and we've said that C inherits from displayable publicly.
What this means is that we can now consider any pointer to a class C instance as a pointer to a displayable instance. As the function display is marked as virtual, when using a pointer do displayable, the function from C will be called, if it exists, and the one in displayable will be called if it does not.
That actually the reason behind making the destructor virtual. You don't want do destruct a displayable, but the actual instance (C in our case)
Now, let's say you've done this on C, D and E, your calling code can be rewritten as:
std::shared_ptr<displayable> f(int i){
std::shared_ptr<displayable> res;
if( i==1 ) { res = std::make_shared<C>(1); }
else if( i==2 ) { res = std::make_shared<D>(2); }
else { res = std::make_shared<E>(i);
return res;
}
int main(){
cout << "/** trace\n\nusing union\n";{
std::shared_ptr<displayable> res = f(1);
res->display();
}
}
