The constructs in a C++ program create, destroy, refer to, access, and manipulate objects. An object is created by a definition, by a new-expression ([expr.new]), by an operation that implicitly creates objects (see below), when implicitly changing the active member of a union, or when a temporary object is created ([conv.rval], [class.temporary]). An object occupies a region of storage in its period of construction ([class.cdtor]), throughout its lifetime, and in its period of destruction ([class.cdtor]).

S>[Note 1: A function is not an object, regardless of whether or not it occupies storage in the way that objects do. — end note]

S>The properties of an object are determined when the object is created. An object can have a name ([basic.pre]). An object has a storage duration ([basic.stc]) which influences its lifetime ([basic.life]). An object has a type ([basic.types]).

S>[Note 2: Some objects are polymorphic ([class.virtual]); the implementation generates information associated with each such object that makes it possible to determine that object's type during program execution. — end note]

V>struct T {int m;};

V>T make()
V>{
V>    T inner;
V>    inner.m = 220;
V>    return inner;
V>}

V>int main()
V>{
V>    const T outer = make();

V>    return 0;
V>}

V>struct T {int m;};

V>int main()
V>{
V>    count T outer{};// только конструктор будет от неконстантного имени. Да я знаю что конструктору плевать, просто отмечаю сей факт

V>    T& inner = const_cast<T&>(outer);
V>    inner.m = 220;

V>    return 0;
V>}

BFE>When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class
BFE>object, even if the constructor selected for the copy/move operation and/or the destructor for the object
BFE>have side effects. In such cases, the implementation treats the source and target of the omitted copy/move
BFE>operation as simply two different ways of referring to the same object.

BFE>>When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class
BFE>>object, even if the constructor selected for the copy/move operation and/or the destructor for the object
BFE>>have side effects. In such cases, the implementation treats the source and target of the omitted copy/move
BFE>>operation as simply two different ways of referring to the same object.

When certain criteria are met, an implementation is allowed to omit the copy/move construction of a class
object, even if the constructor selected for the copy/move operation and/or the destructor for the object
have side effects. In such cases, the implementation treats the source and target of the omitted copy/move
operation as simply two different ways of referring to the same object.

std::map<int, int> buildMap()
{
    std::map<int, int> result; // создали неконстантный объект result, после выполнения конструктора началось время жизни объекта result
    result.insert(42, 43);     // изменили неконстантный объект result
    return result;             // скопировали неконстантный объект result в возвращаемый неконстантный объект (*) - это операция пропускается
                               //   после завершения конструктора временного объекта началось время жизни возвращаемого неконстантного объекта несмотря на то, что операция копирования была пропущена.
                               // перед вызовом деструктора объекта result заканчивается время жизни объекта result
                               // разрушили неконстантный объект result (*) - это операция пропускается
}
const std::map<int, int> someDictionary = buildMap(); // возвращаемый функцией buildMap() неконстантный объект передаётся в конструктор класса map             (*) - это операция пропускается 
                                                      // внутри конструктора возвращаемый функцией buildMap() неконстантный объект перемещается (копируется)   (*) - это операция пропускается
                                                      // после завершения выполнения конструктора                                                              (*) - это операция пропускается 
                                                      //   началось время жизни константного объекта обозначаемого переменной someDictionary 
                                                      // время жизни возвращаемого функцией buildMap() неконстантного объекта окончено  
                                                      // после выполнения выражения возвращаемый функцией buildMap() неконстантный объект разрушается          (*) - это операция пропускается