Использование SFINAE для проверки, может ли тип указателя быть static_cast для другого типа указателя - PullRequest
Новая
       42

Использование SFINAE для проверки, может ли тип указателя быть static_cast для другого типа указателя

0 голосов
/ 22 мая 2018

Фон

Пишу дубль на подвижном QScopedPointer;в основном std::unique_pointer с некоторыми дополнительными аксессуарами.Я запустил его до того, как получил доступ к C ++ 11-совместимому компилятору, но теперь я полон решимости сделать это правильно (хотя я заново изобретаю колесо).

Проблема

Давайте назовем мой умный указатель MyUniquePointer.

Мне нужно знать, можно ли преобразовать тип U * в тип T * через static_cast, а именно: 

template<class T, class Cleanup>
class MyUniquePointer
{
...
template<class U, class CleanupU, class = std::enable_if_t<detail::is_safely_castable<U, T>()>
MyUniquePointer(MyUniquePointer<U, CleanupU> && other) noexcept
    : d(static_cast<T *>(other.release()))
{}
...

Первая половина вопроса

Моя первая попытка заключалась в использовании static_cast внутри enable_if, но вы не можете взять адрес std::declval(), чтобы получить указатель на static_cast!

Есть ли способ использовать test, если указатель на U может быть static_cast на указатель на T с использованием магии шаблона?

ПопыткаОбходной путь

Основываясь на cppreference и этого ответа , я попытался создать шаблонный тест для эмуляции, когда static_cast допустим и, если downcasting, safe .Вот что я собрал до сих пор: 

#include <iostream>
#include <type_traits>
template <class From, class To>
struct is_safely_castable //should probably be is_safely_castable_pointer or something
        : std::integral_constant<bool,
               std::is_pointer<From>() && std::is_pointer<To>()
            && ((std::is_base_of<To, From>()/* && std::has_virtual_destructor<From>()*/)
               || std::is_convertible<From, To>()
               || std::is_same<To,void *>()
               || std::is_same<From, void *>())>
{
};

struct base_type
{
    base_type() = default;
    base_type(base_type &&) = default;
    base_type(const base_type &) = default;
    virtual ~base_type() { }
    base_type &operator=(const base_type &) = default;
    base_type &operator=(base_type &&) = default;
};

struct derived_type : public base_type
{
};

struct unrelated_type
{
};

struct convertible_type
{
    convertible_type(const base_type *) {}
    convertible_type(base_type *) {}
    convertible_type() = default;

    operator base_type *() { return nullptr; }
};

int main(int argc, char *argv[])
{
    (void)(argc);
    (void)(argv);

    base_type *b = new base_type;
    derived_type *d = new derived_type;
    unrelated_type *u = new unrelated_type;
    uint32_t *i32 = new uint32_t{1};
    uint64_t *i64 = new uint64_t{2};
    void *v = static_cast<derived_type *>(d);

    std::cout << std::boolalpha
        << "Base to base:        " << (bool)static_cast<base_type *>(b) << '\n'
        << "Base to derived:     " << (bool)static_cast<derived_type *>(b) << '\n'
        << "Derived to base:     " << (bool)static_cast<base_type *>(d) << '\n'
        << "Unrelated to base:   false\n" //<< static_cast<base_type *>(u) << '\n'
        << "uint32 to uint64:    false\n" //<< static_cast<uint64_t *>(i32) << '\n'
        << "uint64 to uint32:    false\n" //<< static_cast<uint32_t *>(i64) << '\n'
        << "Base to void:        " << (bool)static_cast<void *>(b) << '\n'
        << "Void to derived:     " << (bool)static_cast<derived_type *>(v) << '\n'
        << "Convertible to base: false\n" //<< static_cast<base_type *>(c) << '\n'
        << "Base to convertible: false\n";//<< static_cast<convertible_type *>(b) << '\n';


    std::cout << "-----------\n"
        << "Base to base:        " << is_safely_castable<base_type *, base_type *>() << '\n'
        << "Base to derived:     " << is_safely_castable<base_type *, derived_type *>() << '\n'
        << "Derived to base:     " << is_safely_castable<derived_type *, base_type *>() << '\n'
        << "Unrelated to base:   " << is_safely_castable<unrelated_type *, base_type *>() << '\n'
        << "uint32 to uint64:    " << is_safely_castable<uint32_t *, uint64_t *>() << '\n'
        << "uint64 to uint32:    " << is_safely_castable<uint64_t *, uint32_t *>() << '\n'
        << "Base to void:        " << is_safely_castable<base_type *, void *>() << '\n'
        << "Void to derived:     " << is_safely_castable<void *, derived_type *>() << '\n'
        << "Convertible to base: " << is_safely_castable<convertible_type *, base_type *>() << '\n'
        << "Base to convertible: " << is_safely_castable<base_type *, convertible_type *>() << '\n';

    delete b;
    delete d;
    delete u;
    delete i32;
    delete i64;
    return 0;
}

Wandbox Link

, который возвращает: 

Base to base:        true
Base to derived:     true
Derived to base:     true
Unrelated to base:   false
uint32 to uint64:    false
uint64 to uint32:    false
Base to void:        true
Void to derived:     true
Convertible to base: false
Base to convertible: false
-----------
Base to base:        true
Base to derived:     false
Derived to base:     true
Unrelated to base:   false
uint32 to uint64:    false
uint64 to uint32:    false
Base to void:        true
Void to derived:     true
Convertible to base: false
Base to convertible: false

Вторая половина моеговопросы в том, находится ли этот обходной путь на правильном пути, и, в частности, следует ли включить || std::is_convertible<From, To>().Можно ли сделать так, чтобы is_convertible возвращало true при передаче указателей на типы в качестве параметров шаблона?Приведенный выше код включает мою собственную неуклюжую попытку заставить его работать.

Сноска: я знаю, что base_type * успешно приводит к derived_type *, но я не компилятор и не могу этого сделатьпредположение.

1 Ответ

0 голосов
/ 22 мая 2018

Кажется, вы хотите: 

template <typename T, typename U, typename = void>
struct is_safely_castable : std::false_type {};

template <typename T, typename U>
struct is_safely_castable<T, U,
                          std::void_t<decltype(static_cast<U>(std::declval<T>()))>>
: std::true_type
{};

Демо

...