C ++，捕获不同类型数据的异常

Question

My problem is that I have a template class and i try to catch exceptions of different types of data (int, float, long, char etc).

#include <iostream>
using namespace std;

const int MAX = 3;

template<class Type>
class Stack()
{
    class Range{};
    class Empty{};
    class Input{};

    //Code here
    //Code here
    //If Error: 
    throw Range();
    throw Empty();
    throw Input();
}

int main()
{
    try
    {
        Stack<int> s1
        Stack<float> s2
        Stack<long> s3
        Stack<char> s4
    }
    catch(Stack<int>::Range)   { //Code }
    catch(Stack<float>::Range) { //Code }
    catch(Stack<long>::Range)  { //Code }
    catch(Stack<char>::Range)  { //Code }
    catch(Stack<int>::Empty)   { //Code }
    catch(Stack<float>::Empty) { //Code }
    catch(Stack<long>::Empty)  { //Code }
    catch(Stack<char>::Empty)  { //Code }
    catch(Stack<int>::Input)   { //Code }
    catch(Stack<float>::Input) { //Code }
    catch(Stack<long>::Input)  { //Code }
    catch(Stack<char>::Input)  { //Code }

return 0;
} 

How could I do the same in 3 lines? I have tried:

template <class Type>
catch(Stack<Type>::Range) { }

Error: Expected 'catch' before '<' token       (What's Wrong)


template<class Type>
try { //Code }
catch(Stack<Type>::Range) { }

Error: A template declaration cannot appear at block scope  (Definetely Wrong, I Know)

template<class Type>
int main()
{
    try
    {
        //Code
    }
    catch(Stack<Type>::Range) { }
}

Error: Cannot declare '::main' to be a template   (Of course, That's totally wrong.)

I have tried to declare 'Type' in many places, even though i knew it was wrong. If i don't declare 'Type' it is also wrong. So, is there any way I could do it?

Thanks in advance

Answer 1

Generally, I'm not really sure if defining exceptions as subclasses is a good idea. At least I haven't seen that in any bigger framework (VCL, .NET, stl, but that does not mean, there are none, of course).

I don't have a direct solution to your problem, but if noone comes with a better solution, you can always create a base class for all Range exceptions and catch them by the base class instead of derived ones. If you need a functionality specific to some type, you can always create a virtual method in the base class, like:

class BaseRangeException
{
public:
    virtual void Display() = 0;
}

template<typename T> RangeException 
class RangeException : public BaseRangeException
{
public:
    void Display()
    {
        // Implement differently, depending on type of template
    }
}

Answer 2

If I have such problem (which I'd like to avoid in the first place by changing the whole design of code) I might try to do something like this:

template<typename E>
void TryAndCatch(
    std::function<void (void)> tried,
    std::function<void (const E&) catched>
) {
    try {
        tried();
    } catch (const E& exception) {
        catched(exception);
    }
}

and then use it like this:

TryAndCatch<Stack<int>::Range>(
    []() {
        // tried code in lambda expression
    },
    [](const Stack<int>::Range& exception) {
        // catch code
    }
);

But just looking at it would made me strongly consider rewrite the code so that I would not need to use it, eg like @Spook suggested.

Notice that template needs to be instantiated so either you choose which exception you are catching, and then you use templates to help you somehow (maybe wrap code in some template class that would handle them?) or ensure some common denominator - interface, abstract base class, your choice.