为什么要捕获一个const int和一个int＆work？

Question

In the following code, I throw an int, catch it as const int&, re-throw it and catch it again catch it as an int&.

#include <iostream>

int main()
{
    try
    {
        try
        {
            int x = 1;
            throw x;
        }
        catch(const int& e)
        {
            std::cout << "Inner catch" << std::endl;
            throw;
        }
    }
    catch(int & e1)
    {
        std::cout << "Outer catch" << std::endl;
    }

    return 0;
}

The above program compiles successfully and prints

Inner catch
Outer catch

On the other hand the following program in which I am trying to initialize an int& by a const int& wouldn't even compile.

#include <iostream>
int main()
{
    int x = 0;
    const int& y = x;
    int& z = y 
    return 0;
}

I get the following error as expected

binding ‘const int’ to reference of type ‘int&’ discards qualifiers
     int& z = y

Why am I allowed to catch an const int& as an int& but not able to assign cons int& to int&?

Answer 1

except.handle/3 :

A handler is a match for an exception object of type E if
(3.1) – The handler is of type cv T or cv T& and E and T are the same type ( ignoring the top-level cv-qualifiers ), or [...]

Answer 2

A throw is always by value. You can catch it with a const or with a reference if you want, but the object thrown is always a copy. So it's perfectly safe to catch it with a non- const and to modify it. You can test this by printing the address of an int , then throw it, catch it by reference, and print the address of the reference. You'll see it's a different address.

You can even do this:

try
{
    throw 3;
}
catch (int& q)
{
    q = 4;
}

The value of the thrown object with the value 3 is modified because q binds to a new int initialized with the thrown value. You always throw a value.

The exception is just throw; , which re-throws the existing object. It has to be this way because otherwise, it would be impossible to sanely manage the lifetime of thrown objects.