struct WindowTimerImpl : public WindowTimerBase
{
//...

    WindowTimerImpl(HWND h, UINT_PTR id, timeout_t timeoutMs) {}

    static
    WindowTimerImpl create(HWND h, UINT_PTR requestedId, timeout_t timeoutMs)
    {
        auto id = ::SetTimer(h, requestedId, timeoutMs, 0);

        if (id==0)
        {
            throw std::runtime_error("Failed to create WindowTimer");
        }

        return WindowTimerImpl(h, id, timeoutMs, true);
        // return std::move(WindowTimerImpl(h, id, timeoutMs, true)); // !!! move version
    }

//...
};

    virtual WindowTimer createTimer(timeout_t timeoutMs) const override
    {
        auto pSharedImpl = std::make_shared<WindowTimerImpl>(WindowTimerImpl::create(getHwnd(), curTimerId++, timeoutMs));

//...

template <class _Ty, class... _Types>
_CONSTEXPR20_DYNALLOC void _Construct_in_place(_Ty& _Obj, _Types&&... _Args) noexcept(
    is_nothrow_constructible_v<_Ty, _Types...>) {
#ifdef __cpp_lib_constexpr_dynamic_alloc
    if (_STD is_constant_evaluated()) {
        _STD construct_at(_STD addressof(_Obj), _STD forward<_Types>(_Args)...);
    } else
#endif // __cpp_lib_constexpr_dynamic_alloc
    {
        ::new (_Voidify_iter(_STD addressof(_Obj))) _Ty(_STD forward<_Types>(_Args)...); // !!!
    }
}

struct NonCopiableObject : public IObject
{
    NonCopiableObject() = default;

    NonCopiableObject(const NonCopiableObject&) = delete;
    NonCopiableObject& operator=(const NonCopiableObject&) = delete;

    NonCopiableObject(NonCopiableObject&&) = default;
    NonCopiableObject& operator=(NonCopiableObject&&) = default;

}; // struct NonCopiableObject

struct NonCopiableObject : public IObject
M>{
M>    NonCopiableObject() = default;

M>    NonCopiableObject(const NonCopiableObject&) = delete;
M>    NonCopiableObject& operator=(const NonCopiableObject&) = delete;

M>    NonCopiableObject(NonCopiableObject&&) = default;
M>    NonCopiableObject& operator=(NonCopiableObject&&) = default;

M>}; // struct NonCopiableObject

M>

struct WindowTimerImpl : public WindowTimerBase

S>struct WindowTimerImpl : public WindowTimerBase
S>

struct IWindowTimer : public NonCopiableObject
{

    virtual int compare(const IWindowTimer *pTimer) const = 0;

    virtual bool restart(timeout_t timeoutMs) = 0;

    virtual bool restart() = 0;

    virtual bool stop() = 0;

    virtual bool isStopped() const = 0;

    virtual timeout_t getTimeout() const = 0;

}; // struct IWindowTimer

struct WindowTimerImpl : public IWindowTimer
{
//...

struct NonCopiableObject : public IObject
M>{
M>    NonCopiableObject() = default;

M>    NonCopiableObject(const NonCopiableObject&) = delete;
M>    NonCopiableObject& operator=(const NonCopiableObject&) = delete;

M>    NonCopiableObject(NonCopiableObject&&) = default;
M>    NonCopiableObject& operator=(NonCopiableObject&&) = default;

M>}; // struct NonCopiableObject

template <class _Ty, class... _Types>
shared_ptr<_Ty> make_shared(_Types&&... _Args)

M>>    virtual WindowTimer createTimer(timeout_t timeoutMs) const override
M>>    {
M>>        auto pSharedImpl = std::make_shared<WindowTimerImpl>(WindowTimerImpl::create(getHwnd(), curTimerId++, timeoutMs));

M>>//...
M>>

#include <memory>

struct base
{
    virtual ~base() = default;

    base() = default;

    base(const base &) = delete;
    base & operator=(const base &) = delete;

    base(base &&) = default;
    base & operator=(base &&) = default;
};

struct derived : public base
{
    int a_;
    int b_;

    derived(int a, int b) : a_{a}, b_{b} {}

    [[nodiscard]] static derived create(int a, int b)
    {
        return { a, b };
    }
};

int main()
{
    auto d = std::make_shared<derived>(derived::create(0, 1));
    return d->a_ + d->b_;
}

struct IObject
{
    virtual ~IObject() {}

}; // struct IObject

struct WindowTimerImpl : public IWindowTimer
{

    HWND         hWnd           = 0;
    UINT_PTR     idTimerEvent   = 0;
    timeout_t    timerTimeoutMs = 0;
    bool         running        = false;

    WindowTimerImpl(HWND h, UINT_PTR id, timeout_t timeoutMs, bool bRunning) : hWnd(h), idTimerEvent(id), timerTimeoutMs(timeoutMs), running(bRunning)
    {
        if (running)
        {
            restart();
        }
    }

};

#include <memory>

struct A
{
    A() = default;
    A(A&&) = default;

    A(const A&) = delete;

    static A Create() {return {}; }
};

A makeA() { return {}; }

int main()
{
    const auto sp = std::make_shared<A>(A::Create());
}

If no user-defined move constructors are provided for a class type, and all of the following is true:

there are no user-declared copy constructors;
there are no user-declared copy assignment operators;
there are no user-declared move assignment operators;
there is no user-declared destructor.

Then the compiler will declare a move constructor as a non-explicit inline public member of its class with the signature T::T(T&&).

[ Note: When the move constructor is not implicitly declared or explicitly supplied, expressions that otherwise would have invoked the move constructor may instead invoke a copy constructor. — end note]

struct IObject
{
   IObject() = default;
   IObject(const IObject&) = default;
   IObject& operator = (const IObject&) = default;

   IObject(IObject&&){}
   IObject& operator = (IObject&&) { return *this; }

   virtual ~IObject() {}

}; // struct IObject