Object destructed twice?

If I compile this

Code:

---

#include <iostream>
#include <exception>
using namespace std;

class X
{
    public:
    static int i;
    int count;
    X(){count = ++i; cout << "constructing X object " << count << endl;}
    ~X(){cout << "destructing X object " << count << endl;}
};

int X::i = 0;

void f() throw (X)
{
    throw 1;
}

void g()
{
    cout << "unexpected handler g() called\n";
    throw X();
}

int main()
{
    set_unexpected(&g);
    try
    {
        f();
    }
    catch (X)
    {
        cout << "caught exception X\n";
    }
    catch (int)
    {

        cout << "caught exception int\n";
    }

    return 0;
}

---

The X object thrown by g() appears to get destructed twice. Is this right ? Or is there something very wrong with the program? Or is my compiler sick?

Any ideas?

Try implementing the copy constructor to match what your default constructor does ;)

EDIT:
By the way, you should have caught the X object by const reference instead of by value, though if you did you probably would not have observed the "problem" that you described.

You should always catch by reference.

Soma

Edit: Eh...

So obvious when it's pointed out.

Thanks a million.

Also, see here why you should avoid using Exception Specifications.

Quote:

---

Originally Posted by phantomotap

You should always catch by reference.

---

Yes, and const-reference when possible.

Quote:

---

Yes, and const-reference when possible.

---

True. A catch for a non-constant reference is only useful when you need to patch a polymorphic exception, and if you need to do that you've probably failed anyway.

Soma

Catch by non-const is also useful if you want to supply the exception with additional information and then rethrow. Boost.Exception provides an exception class that you can attach arbitrary information to.