Advice on using templates and vector to improve exception handling

Hi,

I've been trying to improve on my program's exception handling, due to
the amount of code duplication resulting from the following (not to
mention the need to recode when the relevant data required five
variables):

struct three_long_int_misc_exception
{
    std::string ident_string;
    long int err_number1, err_number2, err_number3;
    three_long_int_misc_exception(std::string i="Unknown exception
(three_long_int_misc_exception).", long int x=0, long int y=0, long
int z=0)
    {
        ident_string = i;
        err_number1 = x;
        err_number2 = y;
        err_number3 = z;
    }
};

struct three_unsigned_long_int_misc_exception
{
    std::string ident_string;
    unsigned long int err_number1, err_number2, err_number3;
    three_unsigned_long_int_misc_exception(std::string i="Unknown
exception (three_unsigned_long_int_misc_exception).", unsigned long
int x=0, unsigned long int y=0, unsigned long int z=0)
    {
        ident_string = i;
        err_number1 = x;
        err_number2 = y;
        err_number3 = z;
    }
};

struct four_long_int_misc_exception
{
    std::string ident_string;
    long int err_number1, err_number2, err_number3, err_number4;
    four_long_int_misc_exception(std::string i="Unknown exception
(four_long_int_misc_exception).", long int w=0, long int x=0, long int
y=0, long int z=0)
    {
        ident_string = i;
        err_number1 = w;
        err_number2 = x;
        err_number3 = y;
        err_number4 = z;
    }
};

(There were also structs for when the exception data consisted only of
one or two ints.)

Although the following was a bit more complicated to throw, it seemed
a better idea:

template <typename T> struct multiple_integer_misc_exception
{
    std::string ident_string;
    std::vector<T> error_numbers;

    multiple_integer_misc_exception()
    {
        ident_string = "";
        error_numbers = std::vector<T>(1);
        error_numbers[0] = 0;
    }

    multiple_integer_misc_exception(std::vector<T>& v, std::string
s="Unknown exception (multiple_integer_misc_exception).")
    {
        ident_string = s;
        error_numbers = std::vector<T>(v.size());
        for (int i=0; i < v.size(); i++)
        {
            error_numbers[i] = v[i];
        }
    }
};

However, this doesn't seem to eliminate much of the code duplication
involved in catching the exceptions, as the main() function now needs
to include:

    catch (multiple_integer_misc_exception<long int> lmime) //Is there a
better way than these two almost identical catches?
    {
        std::cout<<'\n'<<lmime.ident_string<<'\t';
        for (int i=0; i<lmime.error_numbers.size(); i++)
        {
            std::cout<<lmime.error_numbers[i]<<' ';
        }
        std::cout<<std::endl;
        return 1;
    }
    catch (multiple_integer_misc_exception<unsigned long int> ulmime)
    {
        std::cout<<'\n'<<ulmime.ident_string<<'\t';
        for (int i=0; i<ulmime.error_numbers.size(); i++)
        {
            std::cout<<ulmime.error_numbers[i]<<' ';
        }
        std::cout<<std::endl;
        return 1;
    }

Can anyone suggest a better way to do this?

Thanks,

James McLaughlin.