Как написать преобразование из Foo<T> в Foo<T const>?
Я пишу класс, наследующий std::unique_ptr для классов, имеющих функцию клонирования:
template <typename T>
class cl_ptr : public std::unique_ptr<T>
{
public:
cl_ptr() noexcept = default;
cl_ptr(T* p) noexcept : std::unique_ptr<T>(p) {}
cl_ptr(cl_ptr<T> const& cp) : std::unique_ptr<T>(cp ? cp->clone() : nullptr) {}
cl_ptr(cl_ptr<T>&&) noexcept = default;
cl_ptr<T>& operator=(cl_ptr<T> const& cp) { this->reset(cp ? cp->clone() : nullptr); return *this; }
cl_ptr<T>& operator=(cl_ptr<T>&& cp) noexcept = default;
~cl_ptr() noexcept = default;
};
У меня возникает ошибка при попытке преобразовать экземпляр типа T в экземпляр типа T const:
cl_ptr<Foo> p1(new Foo);
cl_ptr<Foo const> p2 = p1; // <- Compiler error here
// error: conversion from ‘cl_ptr<Foo>’ to non-scalar type ‘cl_ptr<const Foo>’ requested
Но я не знаю, как это реализовать.
Конечно, я не хочу, чтобы этот код компилировался:
cl_ptr<Foo const> p1(new Foo);
cl_ptr<Foo> p2 = p1; // <- Always wrong
Минимальный воспроизводимый пример:
# include <memory>
template <typename T>
class cl_ptr : public std::unique_ptr<T>
{
public:
cl_ptr() noexcept = default;
cl_ptr(T* p) noexcept : std::unique_ptr<T>(p) {}
cl_ptr(cl_ptr<T> const& cp) : std::unique_ptr<T>(cp ? cp->clone() : nullptr) {}
cl_ptr(cl_ptr<T>&&) noexcept = default;
cl_ptr<T>& operator=(cl_ptr<T> const& cp) { this->reset(cp ? cp->clone() : nullptr); return *this; }
cl_ptr<T>& operator=(cl_ptr<T>&& cp) noexcept = default;
~cl_ptr() noexcept = default;
};
class Foo
{
public:
Foo() = default;
Foo(Foo const&) = default;
~Foo() noexcept = default;
Foo* clone() const { return new Foo(*this); }
};
int main()
{
cl_ptr<Foo> p1(new Foo);
cl_ptr<Foo const> p2 = p1;
cl_ptr<Foo> p3 = p2; // must fail
return 0;
}
std::unique_ptr, как и большинство стандартных классов, не предназначен для наследования.
«Я пишу класс, наследующий от std::unique_ptr» ПОЧЕМУ? Что такое обоснование? Это странное требование. По сути это выглядит как проблема XY.
@molbdnilo: Я знаю. Это не мой вопрос.
@MarekR: вы можете себе представить, что я пишу свою собственную версию умного указателя с нуля и задаю тот же вопрос.
Ваша проблема, если я не пропустил вопрос, не связана ни с std::unique_ptr, ни даже с функцией клонирования. Вы могли бы сократить свой минимальный пример до пустого класса шаблона и увидеть, что A<int> и A<const int> — это два несвязанных типа (поэтому неявное преобразование не работает).
@Caduchon Вот почему это не ответ, а призыв немедленно прекратить это делать.
@Фареанор: верно. Но я ожидаю точно такого же поведения, как и преобразование из std::unique_ptr<T> в std::unique_ptr<T const>. Затем я учитываю контекст.
@Caduchon Это не работает и со std::unique_ptr.
@Fareanor: я думал,shared_ptr
Почему вы «конечно» хотите, чтобы клонирование константного объекта не удалось? Это кажется очень нелогичным.
@Fareanor - конечно, это не сработало, ты его не переместил. Как только вы это сделаете, преобразование не станет проблемой.
@molbdnilo: потому что *p1 — это неконстантный доступ.
@Caduchon Вы можете полностью разыменовать указатель на const.
std::unique_ptr<T>, в частности, имеет шаблонный конструктор (перегрузка (6) здесь), принимающий rзначение типа std::unique_ptr<U> для любого типа U, где U* конвертируется в T*. Так получилось, что Foo* конвертируется в Foo const*, поэтому этот шаблонный конструктор подходит для этого преобразования. Если вы хотите, чтобы ваш класс вел себя как std::unique_ptr, добавьте аналогичный конструктор.
Я бы сделал преобразование явным, используя auto to_const() const -> cl_ptr<T const> { return cl_ptr<T const>{p ? p->clone() : nullptr}; } и, при желании, auto to_mutable() const -> cl_ptr<std::remove_const_t<T>> { return cl_ptr<std::remove_const_t<T>>{p ? p->clone() : nullptr}; }. (Здесь я клонирую, но вы можете изменить основного владельца. Смена владельца для случая to_mutable — (вероятно) очень плохая идея.)
@StoryTeller-UnslanderMonica Ах да, std::unique_ptr не копируется, каким легкомысленным и поспешным писателем я пишу :')
Ответы 2
В общем: нельзя. A<B const> и A<B> могут быть совершенно разными из-за специализации шаблона. Таким образом, в целом экземпляры шаблонов классов с разными списками аргументов шаблона рассматриваются как отдельные, несвязанные типы.
В случае интеллектуальных указателей стандартная библиотека делает все возможное, чтобы разрешить такие преобразования при определенных обстоятельствах, но все это специальные реализации для соответствующего шаблона класса.
Вы можете сделать то же самое для своего конкретного класса. Но cl_ptr кажется тривиальной оберткой для std::unique_ptr, так почему бы не использовать std::unique_ptr напрямую?
Я использую множество контейнеров std::unique_ptr для клонируемых объектов. Компилятору невозможно написать конструктор копирования и оператор присваивания в классах, имеющих такой контейнер.
Я собираюсь разрешить любое преобразование cl_ptr<T> в cl_ptr<U>, где есть преобразование T * в U *, точно так же, как std::unique_ptr. Это позволяет T * к const T * и не позволяет const T * к T *, но также включает Derived * к Base * и т. д.
template <typename T>
class cl_ptr : public std::unique_ptr<T>
{
public:
cl_ptr() noexcept = default;
cl_ptr(T* p) noexcept : std::unique_ptr<T>(p) {}
cl_ptr(cl_ptr<T> const& cp) : std::unique_ptr<T>(cp ? cp->clone() : nullptr) {}
cl_ptr(cl_ptr<T>&&) noexcept = default;
cl_ptr<T>& operator=(cl_ptr<T> const& cp) { this->reset(cp ? cp->clone() : nullptr); return *this; }
cl_ptr<T>& operator=(cl_ptr<T>&& cp) noexcept = default;
template <typename U, typename = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
cl_ptr(cl_ptr<U> const& cp) : std::unique_ptr<T>(cp ? cp->clone() : nullptr) {}
template <typename U, typename = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
cl_ptr(cl_ptr<U>&& cp) noexcept : std::unique_ptr<T>(std::move(cp)) {}
template <typename U, typename = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
cl_ptr<T>& operator=(cl_ptr<U> const& cp) { this->reset(cp ? cp->clone() : nullptr); return *this; }
template <typename U, typename = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
cl_ptr<T>& operator=(cl_ptr<T>&& cp) noexcept { this->reset(cp.release()); return *this; }
~cl_ptr() noexcept = default;
};
Это не минимальный воспроизводимый пример . Где все
#include? Что такоеFoo? Где/как это определяется.