Динамическое литье для unique_ptr

Ответ 1

Функции, к которым вы обращаетесь, делают копию указателя. Поскольку вы не можете сделать копию unique_ptr, нет смысла предоставлять эти функции для нее.

Ответ 2

В дополнение к Mark Ransom answer, unique_ptr<X, D> может даже не хранить X*.

Если делетер определяет тип D::pointer, то то, что хранится и которое может не быть реальным указателем, оно должно удовлетворять требованиям NullablePointer и (если unique_ptr<X,D>::get() вызывается) имеет operator*, который возвращает X&, но не требуется поддерживать листинг для других типов.

unique_ptr довольно гибкий и не обязательно ведет себя очень похоже на встроенный тип указателя.

В соответствии с запросом, вот пример, где хранимый тип не является указателем, и поэтому литье невозможно. Это немного надуманно, но завершает API созданной базы данных (определенный как API-интерфейс C) в API-интерфейсе С++ RAII. Тип OpaqueDbHandle удовлетворяет требованиям NullablePointer, но только сохраняет целое число, которое используется как ключ для поиска фактического соединения с БД посредством определенного отображения, определенного реализацией. Я не показываю это как пример великолепного дизайна, как пример использования unique_ptr для управления не скопированным подвижным ресурсом, который не является динамически выделенным указателем, где "deleter" не просто вызывает вызов деструктор и освободить память, когда unique_ptr выходит за рамки.

#include <memory>

// native database API
extern "C"
{
  struct Db;
  int db_query(Db*, const char*);
  Db* db_connect();
  void db_disconnect(Db*);
}

// wrapper API
class OpaqueDbHandle
{
public:
  explicit OpaqueDbHandle(int id) : id(id) { }

  OpaqueDbHandle(std::nullptr_t) { }
  OpaqueDbHandle() = default;
  OpaqueDbHandle(const OpaqueDbHandle&) = default;

  OpaqueDbHandle& operator=(const OpaqueDbHandle&) = default;
  OpaqueDbHandle& operator=(std::nullptr_t) { id = -1; return *this; }

  Db& operator*() const;

  explicit operator bool() const { return id > 0; }

  friend bool operator==(const OpaqueDbHandle& l, const OpaqueDbHandle& r)
  { return l.id == r.id; }

private:
  friend class DbDeleter;
  int id = -1;
};

inline bool operator!=(const OpaqueDbHandle& l, const OpaqueDbHandle& r)
{ return !(l == r); }

struct DbDeleter
{
  typedef OpaqueDbHandle pointer;

  void operator()(pointer p) const;
};

typedef std::unique_ptr<Db, DbDeleter> safe_db_handle;

safe_db_handle safe_connect();

int main()
{
  auto db_handle = safe_connect();
  (void) db_query(&*db_handle, "SHOW TABLES");
}


// defined in some shared library

namespace {
  std::map<int, Db*> connections;      // all active DB connections
  std::list<int> unused_connections;   // currently unused ones
  int next_id = 0;
  const unsigned cache_unused_threshold = 10;
}

Db& OpaqueDbHandle::operator*() const
{
   return connections[id];
}

safe_db_handle safe_connect()
{
  int id;
  if (!unused_connections.empty())
  {
    id = unused_connections.back();
    unused_connections.pop_back();
  }
  else
  {
    id = next_id++;
    connections[id] = db_connect();
  }
  return safe_db_handle( OpaqueDbHandle(id) );
}

void DbDeleter::operator()(DbDeleter::pointer p) const
{
  if (unused_connections.size() >= cache_unused_threshold)
  {
    db_disconnect(&*p);
    connections.erase(p.id);
  }
  else
    unused_connections.push_back(p.id);
}

Ответ 3

Чтобы построить ответ на Дэйв, эта функция шаблона попытается переместить содержимое одного unique_ptr в другой тип.

• Если он возвращает true, то либо:
  • Исходный указатель был пуст. Указатель адресата будет очищен, чтобы выполнить семантический запрос "переместить содержимое этого указателя (ничего) в это."
  • Объект, на который указывает указатель источника, был конвертирован в тип указателя адресата. Исходный указатель будет пустым, а указатель назначения укажет на тот же объект, на который он указывал. Указатель адресата получит отладчик указателя источника (только при использовании первой перегрузки).
• Если он возвращает false, операция не удалась. Ни один указатель не изменит состояние.

template <typename T_SRC, typename T_DEST, typename T_DELETER>
bool dynamic_pointer_move(std::unique_ptr<T_DEST, T_DELETER> & dest,
                          std::unique_ptr<T_SRC, T_DELETER> & src) {
    if (!src) {
        dest.reset();
        return true;
    }

    T_DEST * dest_ptr = dynamic_cast<T_DEST *>(src.get());
    if (!dest_ptr)
        return false;

    std::unique_ptr<T_DEST, T_DELETER> dest_temp(
        dest_ptr,
        std::move(src.get_deleter()));

    src.release();
    dest.swap(dest_temp);
    return true;
}

template <typename T_SRC, typename T_DEST>
bool dynamic_pointer_move(std::unique_ptr<T_DEST> & dest,
                          std::unique_ptr<T_SRC> & src) {
    if (!src) {
        dest.reset();
        return true;
    }

    T_DEST * dest_ptr = dynamic_cast<T_DEST *>(src.get());
    if (!dest_ptr)
        return false;

    src.release();
    dest.reset(dest_ptr);
    return true;
}

Обратите внимание, что вторая перегрузка требуется для указателей, объявленных std::unique_ptr<A> и std::unique_ptr<B>. Первая функция не будет работать, потому что первый указатель будет фактически иметь тип std::unique_ptr<A, default_delete<A> >, а второй из std::unique_ptr<A, default_delete<B> >; типы дебетеров не будут совместимы, поэтому компилятор не позволит вам использовать эту функцию.

Ответ 4

Это не ответ на вопрос, почему, но это способ сделать это...

std::unique_ptr<A> x(new B);
std::unique_ptr<B> y(dynamic_cast<B*>(x.get()));
if(y)
    x.release();

Это не совсем чисто, так как на короткое время 2 unique_ptr считают, что у них есть один и тот же объект. И, как было прокомментировано, вам также придется управлять перемещением пользовательского делетера, если вы используете один (но это очень редко).

Ответ 5

Как насчет этого для подхода С++ 11:

template <class T_SRC, class T_DEST>
std::unique_ptr<T_DEST> unique_cast(std::unique_ptr<T_SRC> &&src)
{
    if (!src) return std::unique_ptr<T_DEST>();

    // Throws a std::bad_cast() if this doesn't work out
    T_DEST *dest_ptr = &dynamic_cast<T_DEST &>(*src.get());

    src.release();
    return std::unique_ptr<T_DEST> ret(dest_ptr);
}

Ответ 6

Если вы только собираетесь использовать указатель понижения в малой области видимости, одна альтернатива заключается в том, чтобы просто сбрасывать ссылку на объект, управляемый с помощью unique_ptr:

auto derived = dynamic_cast<Derived&>(*pBase);
derived.foo();