#include <memory>
#include <functional>
#include <iostream>

using namespace std;

void foo(shared_ptr<int> ptr) { cout << "foo shared: " << *ptr << endl; }
void bar(unique_ptr<int> ptr) { cout << "bar unique: " << *ptr << endl; }

int main()
{
    auto s = make_shared<int>(7);
    function<void()> foo_f = bind(&foo, move(s));
    foo_f();

    auto u = make_unique<int>(7);
    function<void()> bar_f = bind(&bar, move(u)); // error: conversion from 'std::_Bind_helper<false, void (*)(std::unique_ptr<int>)...
    bar_f();

    return 0;
}

V>class Car;
V>class Engine;

V>class Car
V>{
V>    upl::unique<Engine> engineStrong;   //рассматриваем этот unique как полюс ассоциации "машина [0,1] -- [0,1] двигатель"
V>    upl::weak<Engine>   engineWeak;     //альтернативный полюс для engineStrong. Вот про него речь. С ним проблемы.
V>};

V>class Engine
V>{
V>    unspecified<Car> car;               //противоположный для engineStrong+engineWeak, может быть upl::weak, а может что то другое. Не интересует
V>};
V>

class Monitor
{
    upl::weak<Engine> engineWeak;
}

class UniqueEngine {
  std::shared_ptr<Engine> engine_;
public:
  UniqueEngine(const UniqueEngine &) = disable;
  UniqueEngine(UniqueEngine &&) = default;
  UniqueEngine(std::unique_ptr<Engine> en) : engine_(std::move(en)) {}
  ...
  std::weak_ptr<Engine> weak_ref() { return {engine_}; }
  ...
};
...
class Car {
  UniqueEngine engine_;
  ...
public:
  auto engine() { return engine_.weak_ref(); }
};
class Monitor {
  std::weak_ptr<Engine> engine_;
  ...
};

class Car : public std::enable_shared_from_this {
  Engine engine_;
public:
  std::weak_ptr<Engine> engine() {
    return { std::shared_ptr<Engine>(shared_from_this(), &engine) };
  };
};

VT>Если вам хватает функциональности std::shared_ptr, и не нужны всякие псевдоконцепции, то и ладно

function<void()> foo_f = [&]{foo(move(s));};
function<void()> bar_f = [&]{bar(move(u));};

_NN>function<void()> foo_f = [&]{foo(move(s));};
_NN>function<void()> bar_f = [&]{bar(move(u));};
_NN>

#include <memory>
#include <functional>
#include <vector>
#include <iostream>

using namespace std;

void bar(unique_ptr<int> ptr) { cout << "bar unique: " << *ptr << endl; }

int main()
{
    vector<function<void()>> commands;
    {
        auto u = make_unique<int>(7);
        commands.push_back([&] { bar(move(u)); });
    }
    commands[0]();

    return 0;
}

V>Ну, тут сплошные засады Ты просто накладываешь полезняшки на чашу весов какого то своего скрытого кейса. Но надо понимать, что если ты на свою чашу что то добавил — то с другой забрал. Например, ты убил детерминированность времени жизни указываемого объекта, а существует большое число прикладных кейсов, в которых такая детерминированность нужна/полезна. Например, ты существенно увеличил расход ресурсов потому что для твоего кейса это не существенно, но для многих перерасход будет фатальным. Клоню к тому, что "унификации" не получилось. Получился какой то сугубо конкретный тул. Да еще и чужую терминологию употребил, чем сбил всех с толку, а с so5team даже подрался

Указатели UPL не являются заменой умных указателей стандартной библиотеки C++ и могут использоваться совместно с ними (конечно, одновременно объект может находиться под управлением только одной библиотеки). UPL предназначена для случаев, когда не хватает функциональности умных указателей стандартной библиотеки C++ и требуются дополнительные возможности для организации связей между объектами в многопоточной среде.

Указатель upl::weak может ссылаться на объект, который находится под управлением upl::unique