c++ - 获取任何 C++ 可取消引用类型的基础类型

Question

我有一个函数可以创建 P 基础类型的新对象。这里的 P 是一个可取消引用的类型，如指针或智能指针。

template<typename P>
auto make_new()

例如对于指针和智能指针，

struct A
{
    int a = 3;
};

A* a = make_new<A*>();
std::cout << a->a << std::endl;
delete a;

std::shared_ptr<A> b = make_new<std::shared_ptr<A>>();
std::cout << b->a << std::endl;

现在，对于共享指针，我将按如下方式实现 make_new，

template<typename P>
auto make_new()
{
    using Ptype = typename P::element_type;
    return P(new Ptype);
}

这不适用于指针。

现在，一些同时适用于指针和智能指针的东西，

template<typename P>
auto make_new()
{
    using Ptype = typename std::remove_reference<decltype(*P())>::type;
    return P(new Ptype);
}

但不适用于 std::optional。

是否有获取可取消引用对象的基础类型的规范方法？

我知道 * 和 -> 可以重载到任何东西，并且不能保证构造函数像上面那样工作，或者这样做是有意义的。

只是想知道是否有办法，而不仅仅是找到它，或者只是做一些愚蠢的事情。

Answer 1

在指针和类上解析元素类型

目标。我们的目标是写一个using模板以可取消引用的类型作为输入，并返回元素类型。

template<class T>
using element_type_t = /* stuff */;

方法。我们可以使用 SFINAE 检查是否有 element_type属性，如果没有，我们将退回到使用 std::remove_reference<decltype(*P())>() .

// This is fine to use in an unevaluated context
template<class T>
T& reference_to(); 

// This one is the preferred one
template<class Container>
auto element_type(int) 
  -> typename Container::element_type;

// This one is the fallback if the preferred one doesn't work
template<class Container>
auto element_type(short) 
  -> typename std::remove_reference<decltype(*reference_to<Container>())>::type;

一旦有了这个函数，我们就可以写element_type_t通过获取 element_type 的返回类型.

// We alias the return type
template<class T>
using element_type_t = decltype(element_type<T>(0)); 

为什么我们不能始终通过取消引用来获取 element_type？如果您尝试始终使用 * 获取值类型运算符，这可能会导致诸如 std::vector<bool> 的迭代器之类的问题，它返回一个对象，其行为类似于 bool，但封装了位操作。在这些情况下，元素类型不同于取消引用返回的类型。

判断构造函数接受的是指针还是值

您的代码因 std::optional 而失败的原因是因为std::optional的构造函数采用值本身，而不是指向该值的指针。为了确定我们需要哪个构造函数，我们再次使用 SFINAE 进行确定。

// Base case - use new operator
template<class Container>
auto make_new_impl(int) 
    -> decltype(Container{new element_type_t<Container>})
{
    return Container{new element_type_t<Container>};
}

// Fallback case, where Container takes a value
template<class Container>
auto make_new_impl(long)
    -> decltype(Container{element_type_t<Container>()})
{
    return Container{element_type_t<Container>()};
}

现在，我们可以写make_new所以它调用make_new_impl :

template<class Container>
auto make_new() {
    return make_new_impl<Container>(0);
}

示例。我们现在可以使用 make_new制作 std::optional , std::shared_ptr ，甚至是常规指针。

#include <optional>
#include <memory>

int main() {
    // This works
    int* ptr = make_new<int*>(); 

    // This works too
    std::shared_ptr<int> s = make_new<std::shared_ptr<int>>();

    // This also works
    std::optional<int> o = make_new<std::optional<int>>(); 
}