#include <iostream>

struct X {};
struct Y {};

void test(int t)
{
    try
    {
        int v = (t>0)
            ?
                (
                    std::cout << "throwing...",
                    throw
                    (
                        (t>1)
                        ?
                            (
                                std::cout << "throwing X()...",
                                throw X(),
                                Y()
                            )
                        :
                            Y()
                    ),
                    123
                )
            : 456;
        std::cout << "passed " << v << std::endl;
    }
    catch(X)
    {
        std::cout << "caught X" << std::endl;
    }
    catch(Y)
    {
        std::cout << "caught Y" << std::endl;
    }
}

int main()
{
    test(0);
    test(1);
    test(2);
}

class Foo
{
    .....
    Foo()
    {
        Foo copy (*this); // UB?
    }
    .....
};

К>class Foo
К>{
К>    .....
К>    Foo()
К>    {
К>        Foo copy (*this); // UB?
К>    }
К>    .....
К>};

3.8 Object Lifetime [basic.life]

1: The lifetime of an object is a runtime property of the object. The lifetime of an object of type T begins when:

• storage with the proper alignment and size for type T is obtained, and
  
• if T is a class type with a non-trivial constructor (12.1), the constructor call has completed.

3.8/6:[…] before the lifetime of an object has started but after the storage which the object will occupy has been allocated […] any lvalue which refers to the original object may be used but only in limited ways. […] If an lvalue-to-rvalue conversion (4.1) is applied to such an lvalue, the program has undefined behavior; if the original object will be or was of a non-POD class type, the program has undefined behavior if:

• the lvalue is used to access a non-static data member or call a non-static member function of the object, or
  
• the lvalue is implicitly converted (4.10) to a reference to a base class type, or
  
• the lvalue is used as the operand of a static_cast (5.2.9) (except when the conversion is ultimately to char& or unsigned char&), or
  
• the lvalue is used as the operand of a dynamic_cast (5.2.7) or as the operand of typeid.

К>class Foo
К>{
К>    .....
К>    Foo()
К>    {
К>        Foo copy (*this); // UB?
К>    }
К>    .....
К>};
К>

If the object will be or was of a non-POD class type, the program has
undefined behavior if:
— the pointer is used to access a non-static data member or call a non-static member function of the object

                    throw
                    (
                        (t>1)
                        ?
                            (
                                std::cout << "throwing X()...",
                                throw X(),
                                Y()
                            )
                        :
                            Y()
                    ),
                    123

12.6.2/9
Member functions (including virtual member functions, 10.3) can be called for an object under construction.
Similarly, an object under construction can be the operand of the typeid operator (5.2.8) or of a dynamic_-
cast (5.2.7). However, if these operations are performed in a ctor-initializer (or in a function called directly
or indirectly from a ctor-initializer) before all the mem-initializers for base classes have completed, the result
of the operation is undefined.
[ Example:

class A {
public:
  A(int);
};

class B : public A {
  int j;
public:
  int f();
  B() : A(f()), // undefined: calls member function
                // but base A not yet initialized
  j(f()) { } // well-defined: bases are all initialized
};

—end example ]

12.6.2/9
Member functions (including virtual member functions, 10.3) can be called for an object under construction.
Similarly, an object under construction can be the operand of the typeid operator (5.2.8) or of a dynamic_-
cast (5.2.7). However, if these operations are performed in a ctor-initializer (or in a function called directly
or indirectly from a ctor-initializer) before all the mem-initializers for base classes have completed, the result
of the operation is undefined.