ranges
coroutines
concepts
modules

class ComplexObject {
    ComplexObject(int) {}
    friend ComplexObject createComplexObject();
    
    ComplexObject() = delete;
    ComplexObject(ComplexObject&&) = delete;
    ComplexObject(const ComplexObject&) = delete;
};

ComplexObject createComplexObject()
{
    return ComplexObject(0);
}

S>>class ComplexObject {
S>>    ComplexObject(int) {}
S>>    friend ComplexObject createComplexObject();
    
S>>    ComplexObject() = delete;
S>>    ComplexObject(ComplexObject&&) = delete;
S>>    ComplexObject(const ComplexObject&) = delete;
S>>};

S>>ComplexObject createComplexObject()
S>>{
S>>    return ComplexObject(0);
S>>}
S>>

class MyDeserializer
{
public:

  ComplexObject DeserializeComplexObject();
}

S>ComplexObject createComplexObject()
{
    // как сообщаем об ошибках здесь? Только исключения
    ...
    return ComplexObject(0);
}

#include <iostream>
#include <string>
#include <vector>
#include <memory>

struct Foo
{
    const int id;

    explicit Foo(int id) : id(id) {}

    Foo() = delete;
    Foo(const Foo&) = delete;
    Foo& operator=(const Foo&) = delete;
    ////////////////////////////////////////////////////////////////////////////////////////////////
    Foo(Foo&&) = delete;            // перемещение не обязательно запрещать явно
    Foo& operator=(Foo&&) = delete; // оно автоматически запрещается, когда мы запрещаем копирование

    void test() const { std::cout << "Foo: " << id << std::endl; }
};

Foo make_foo()
{
    static int last_id {};
    return Foo(++last_id);
}

int main()
{
    auto foo = make_foo();
    const auto uptr = std::unique_ptr<Foo>(new Foo(make_foo()));
    const auto sptr = std::shared_ptr<Foo>(new Foo(make_foo()));

    foo.test();
    uptr->test();
    sptr->test();
}