Т.е. A& a_ref(guard_ptr a_guard) { a_guard_ = std::move(a_guard); return a; }

1.unique_ptr нельзя так передавать

Тут очень просто - если я запрашиваю поле объекта, и этот объект не мое поле, я должен положить в его поле отзыв переданного мне

Ну там move забыт

Давайте код целиком

примерно так //у нас есть апиха для работы с guard_ptr //guard_ptr make_guard(noexcept lambda) //есть вспомогательный тип ref_with_guard //по сути pair<A&, guard_ptr> только в одном указателе //неперемещаемый с одним слотом для простоты struct B { ref_with_guard<A> a_ref(guard_ptr a_guard) & { a_guard_ = std::move(a_guard); return { a, [this] () { a_guard_ = nullptr; } }; } private: A a; guard_ptr a_guard_; }; //пользователь В, неперемещаемый struct BUser { ref_with_guard<A> a; void init_with_b(B& b) { a = b.a_ref(make_guard([this] () { a = nullptr; })); } };

unique_ptr нельзя вот так передавать в параметре функции. Только по ссылке (любой). Код не скомпилируется.

вы ошибаетесь

Только через move.

Только через move.

примерно так //у нас есть апиха для работы с guard_ptr //guard_ptr make_guard(noexcept lambda) //есть вспомогательный тип ref_with_guard //по сути pair<A&, guard_ptr> только в одном указателе //неперемещаемый с одним слотом для простоты struct B { ref_with_guard<A> a_ref(guard_ptr a_guard) & { a_guard_ = std::move(a_guard); return { a, [this] () { a_guard_ = nullptr; } }; } private: A a; guard_ptr a_guard_; }; //пользователь В, неперемещаемый struct BUser { ref_with_guard<A> a; void init_with_b(B& b) { a = b.a_ref(make_guard([this] () { a = nullptr; })); } };

Так как же эту конструкцию использовать?

И что делает make_guard мне не понятно. Создаёт объект?

Создает unique_ptr на VirtuallyDestructible который выполнит параметр в деструкторе

Всё равно не понятно, кто владеет А: guard_ptr или B.

примерно так //у нас есть апиха для работы с guard_ptr //guard_ptr make_guard(noexcept lambda) //есть вспомогательный тип ref_with_guard //по сути pair<A&, guard_ptr> только в одном указателе //неперемещаемый с одним слотом для простоты struct B { ref_with_guard<A> a_ref(guard_ptr a_guard) & { a_guard_ = std::move(a_guard); return { a, [this] () { a_guard_ = nullptr; } }; } private: A a; guard_ptr a_guard_; }; //пользователь В, неперемещаемый struct BUser { ref_with_guard<A> a; void init_with_b(B& b) { a = b.a_ref(make_guard([this] () { a = nullptr; })); } };

Всем ку cppreference про std::array::front, в частности, говорит: Calling front on an empty container is undefined. Допускается ли реализация, которая вызывает ошибку компиляции?

WAID WUT?

Что-то неясно?)

Всем ку cppreference про std::array::front, в частности, говорит: Calling front on an empty container is undefined. Допускается ли реализация, которая вызывает ошибку компиляции?

Всем привет, кто-нибудь пользуются PVS-Studio?

нет, не допускается

Всем ку cppreference про std::array::front, в частности, говорит: Calling front on an empty container is undefined. Допускается ли реализация, которая вызывает ошибку компиляции?

я

Можешь скинуть любой html отчёт? Нужно сделать одноразовый отчёт и хочу взять за базу их версию.

но это легко обходится - делается варнинг на это и пишется -Werror (если компилятор может доказать, что ты творишь дичь)

У гцц посмотри

непонятно, как имплементить эти функции без массива) вроде как, нет легальных путей сделать ссылку на nullptr

у Microsoft array<T, 0> содержит массив единичной длины

прикольно т.е. если T не default-constructible, то будет ошибка при инстанцировании такого массива?

А ты будешь объявлять массив не default constructible типов?

А кто-нибудь разбирался с "Core Coroutines" http://open-std.org/JTC1/SC22/WG21/docs/papers/2018/p1063r1.pdf ?

прикольно т.е. если T не default-constructible, то будет ошибка при инстанцировании такого массива?

Жёсткое ограничение, что ссылкой на А владеет только один BUser, никуда не уходит.

А ты будешь объявлять массив не default constructible типов?

То, что сброс в nullptr user2.a произойдёт раньше времени уничтожения B.a вопросов не вызывает. Нюанс заключается в том, что в деструкторе A нет возможности обратиться к объемлющему классу B, т.к. он на тот момент уже разрушен. В моём примере такая возможность есть.

а почему это должно отличаться от основного случая size != 0?

В деструкторе класса А нельзя обратиться к полному В, потому что он уже не содержит А ;)

Условие: объект A не переживает объект B. Объект A создаётся в рамках жизни объекта B. Мы хотим передать ссылку на A во внешнюю среду. Решение в рамках shared_ptr: using namespace std; class B : enable_shared_from_this { public: class A { shared_ptr<B> strong_ref; A(const shared_ptr<B>& b) : strong_ref(b) {} } private: weak_ptr<A> _a; B() = default; public: static shared_ptr<B> CreateB() { return make_shared<B>(); } shared_ptr<A> GetA() { if (auto a = _a.lock()) return a; auto a = make_shared<A>(shared_from_this()); _a = a; return a; } } P.S. с телефона я пишу код долго.

Я пока пытаюсь весь код понять. a = nullptr сбивает с толку в последнем методе. Я так понимаю, привэсваиыается пустой ref_with_guard, что в момент разрушения BUser не имеет большого смысла

О! Точно, там надо явный деструктор писать для BUser

ну вроде бы не пустой array всегда можно проинициализировать кастомными значениями

как ни странно у Microsoft пустой array тоже можно проинициализировать кастомным значением :)) std::array<Foo, 0> myArr { Foo(1) };

@webreh ^ вот здесь обратное поведение.

Да, но будет ли такой код переносимым?)

Это так не сработает. Вы не можете обращаться полноценно к В из деструктора А в вашем примере. Попытка использовать любой метод, требующий А, в деструкторе класса А приведет к UB (бесконечный цикл без side effect), которое будет зависанием из-за того, что компилятор не оптимизирует через аллокацию памяти

Согласен, но уведомить любым образом B о том, что объект A разрушился, можно.

Не понял про слоты. В такой архитектуре пользователи должны пользоваться ресурсом последовательно, явно переключая владение методом init_with_b. B b; BUser user1; user1.init_with_b(b); BUser user2; user2.init_with_b(b); // в этом месте user1.a.first == nullptr;

@webreh каким образом, если вот эта штука ^ не работает?

@webreh каким образом, если вот эта штука ^ не работает?

Там если надо несколько копий придется чуть больше кодить

guard_ptr заменится на что-то, что умеет хранить и искать чуть более одного

нет, не допускается

Только зваться деструктивор ref_with_guard будет *после* деструктора B

Да, но если деструктор В вызвался, он первым делом занулит a_guard_ который занулит ref_with_guard, так что деструктор будет с nullptr Там нужно явно прописывать присваивание в nullptr в деструкторе или использовать исправленный unique_ptr но это тонкости

И не забыть такие guard'ы указывать в конце списка объявления переменных и по одному guard'у на переменную.

А в С++ вообще не стоит путать порядок зависимостей в полях объекта

Для этого их все нужно держать в голове :)

Имхо, в большом проекте я бы запутался.

Мне дубли такого рода сложно воспринимать. Уже привык, что 1 нетривиальная переменная = 1 сущность.

примерно так //у нас есть апиха для работы с guard_ptr //guard_ptr make_guard(noexcept lambda) //есть вспомогательный тип ref_with_guard //по сути pair<A&, guard_ptr> только в одном указателе //неперемещаемый с одним слотом для простоты struct B { ref_with_guard<A> a_ref(guard_ptr a_guard) & { a_guard_ = std::move(a_guard); return { a, [this] () { a_guard_ = nullptr; } }; } private: A a; guard_ptr a_guard_; }; //пользователь В, неперемещаемый struct BUser { ref_with_guard<A> a; void init_with_b(B& b) { a = b.a_ref(make_guard([this] () { a = nullptr; })); } };

Я думаю, пора тему закрывать. И тот, и тот подход имеет право на жизнь. Ваш мне сложнее для запоминания.

А есть какие-нибудь особенности с class template instantiation у boost::variant? Все вроде как работало, затем разнес в header/cpp-impl в виде extern template class/template class и компилятор (clang 8) стал ругаться на invalid operands to binary expression (const T, const T)

Тут проблема, что ваш это подход, видимо, привнесенный из Java/C#