class Widget {    // Three alternative implementations represented as a union
    private:
        enum class Tag { point, number, text } type;    // discriminant
        union {        // representation
            point p;      // point has constructor
            int i;
            string s;     // string has default constructor, copy operations, and destructor
        };
        // ...
        widget& operator=(const widget& w)     // necessary because of  the string variant
        {
            if (type==Tag::text && w.type==Tag::text) {
                s = w.s;        // usual string assignment
                return *this;
            }

            if (type==Tag::text) s.~string();    // destroy (explicitly!)

            switch (type==w.type) {
            case Tag::point: p = w.p; break;    // normal copy
            case Tag::number: i = w.i; break;
            case Tag::text: new(&s)(w.s); break;    // placement new
            }
            type = w.type;
            return *this;
        }
    };

C>>new(&s)(w.s); — такое в операторе присваивания, это бесплатное пособие по UB

s.~string();

new(&s)(args); // (2)

new(&s)(args); // thrown exception, oops: type == Tag::text
type = w.type; // never reach this code
//next call 
if (type==Tag::text) s.~string(); // oops, UB

enum class ScopedTag { tag1, tag2, tag3 }; 
enum UnscopedTag { unscopedTag1, unscopedTag2, unscopedTag3 }; 

ScopedTag x = ScopedTag::tag1; // ok
ScopedTag y = tag2; // error
int ix = x; // error
double dx = x; // error

UnscopedTag x_ = unscopedTag1; // ok
UnscopedTag y_ = unscopedTag2; // ok
int ix_ = x_; // ok
double dx_ = x_; // ok

C>>>            switch (type==w.type) {
C>>>

switch (type_ = w.type_)