How to check is_unique_ptr?

Question

What is the "universal" to check a pointer is std::unique_ptr, which works with const & and custom deleters. Maybe is there any way to check all smart pointers at once?

I want to

write some function to check empty variant, if it contains only pointers (i.e raw, std::unique_ptr, std::shared_ptr) and
check instantiation of it by std::enable_if

But what I should write in condition?

template <typename... T>
std::enable_if_t<???, bool>
IsEmptyVariantOfPointers(const std::variant<T...>& variant)
{
    bool emptyVariant = true;
    std::visit([&emptyVariant](auto&& arg)
    {
        emptyVariant = arg == nullptr;
    }, variant);

    return emptyVariant;
}

NOTE: I'm interested the option without template function overloading by pointer types.

it is unclear what you want to check. If `T` is `std::unique_ptr` ? — 463035818_is_not_an_ai, Feb 13 '23 at 13:46
smart pointers aren't really pointers. There is no universal way to detect smartness. Suppose you are using a library called `foo`, then you only know from documentation whether `foo::bar` is some kind of smart pointer or not — 463035818_is_not_an_ai, Feb 13 '23 at 13:47
[`std::is_same`](https://en.cppreference.com/w/cpp/types/is_same) — 463035818_is_not_an_ai, Feb 13 '23 at 13:49

JeJo · Accepted Answer · 2023-02-13T14:10:31.817

Maybe there are ways to check all smart pointers at once?

You can write a trait which checks the type of the passed template class to be a certain template class type, as follows:

template<typename Type, template<typename...> class Args>
struct is_specialization_of final : std::false_type {};

template<template<typename...> class PointerType, typename... Args>
struct is_specialization_of<PointerType<Args...>, PointerType> final: std::true_type {};

Now provide a variable template of type bool which checks the template classes (i.e. smart pointers or any customer pinter classes).

template<typename PointerType>
inline constexpr bool is_std_smart_ptr =
   is_specialization_of<PointerType, std::unique_ptr>::value
|| is_specialization_of<PointerType, std::shared_ptr>::value;

This can be used in the std::enable_if_t as follows. For simplicity, I have replaced the variadic template arguments with a simple template argument. I leave the variadic version to you.

template <typename T>
std::enable_if_t<is_std_smart_ptr<T>, bool>
IsEmptyVariantOfPointers(const std::variant<T>& variant) {
     // .....
}

What are the universal ways to check is_unique_ptr?

If the actual intention is only to find the std::unique_ptr, (one way) you can write dedicated traits for it.

template <typename...> struct is_std_unique_ptr final : std::false_type {};
template<class T, typename... Args>
struct is_std_unique_ptr<std::unique_ptr<T, Args...>> final : std::true_type {};

What's up with `final` on traits? Inheriting one trait from another is a valid usecase. For example, [`std::conjunction`](https://en.cppreference.com/w/cpp/types/conjunction) does that. — HolyBlackCat, Feb 13 '23 at 14:22
@HolyBlackCat Final is optional here. (IMHO) Nothing to nitpick for a silly thing. BTW fold expression comes in handy instead of `std::conjunction` or like traits as well, if the `::value` being variable templated. — JeJo, Feb 13 '23 at 14:30

How to check is_unique_ptr?

1 Answers1