C++ 从模板参数的子类推断函数模板参数

我的问题与类似，但有点复杂

我想创建一个工厂函数，它可以推断其结果的类型，这样我就不必自己编写它，而是使用auto（如下面的

auto b=…

或

auto b3=…

）

我可以让代码使用普通指针，但当我将它们更改为

unique\u ptr

s时，编译器会抱怨

下面是示例代码

#include <iostream>
#include <memory>

template <typename T>
struct A {
    T fA() const { return T(); }
};

struct Aint : A<int> {};

template <typename T>
struct B {
    B(std::unique_ptr<A<T>> ptr) : ptr_(std::move(ptr)) {}
    B(A<T>* ptr) : ptr_(ptr) {}
    std::unique_ptr<A<T>> ptr_;
};

template <typename T>
std::unique_ptr<B<T>> CreateB(A<T>* a) {
    return std::unique_ptr<B<T>>(new B<T>(a));
}

template <typename T>
std::unique_ptr<B<T>> CreateBFromUnique(std::unique_ptr<A<T>> a) {
    return std::unique_ptr<B<T>>(new B<T>(std::move(a)));
}

int main() {
    auto b = CreateB(new Aint);
    std::cout << b->ptr_->fA() << "\n";

    std::unique_ptr<Aint> a(new Aint);
    // call below fails to compile
    auto b2 = CreateBFromUnique(std::move(a));
    // This works fine.
    auto b3 = CreateBFromUnique<int>(std::move(a));
}

#包括
#包括
模板
结构A{
T fA（）常量{return T（）；}
};
结构Aint:A{}；
模板
结构B{
B（std：：unique_ptr ptr）：ptr（std：：move（ptr））{
B（A*ptr）：ptr_（ptr）{}
std：：唯一的ptr ptr；
};
模板
std:：unique_ptr CreateB（A*A）{
返回std:：unique_ptr（新B（a））；
}
模板
std:：unique\u ptr CreateBFromUnique（std:：unique\u ptr a）{
返回std:：unique_ptr（新B（std:：move（a））；
}
int main（）{
自动b=创建b（新的AIT）；
当然，有多种方法可以做到这一点，但是

#include <memory>

template <typename T> T AtypeHelper(A<T>*){}
template <typename T>
using Atype = decltype(AtypeHelper((T*)0));

template <typename U, typename T = Atype<U>>
  std::unique_ptr<B<T>> CreateBFromUnique(std::unique_ptr<U> a) {
  return MakeUnique<B<T>>(std::move(a));
}

int main() {
    auto b = CreateBFromUnique(MakeUnique<Aint>());
}

#包括
模板T AtypeHelper（A*）{}
模板
使用Atype=decltype（atypeheloper（（T*）0））；
模板
std:：unique\u ptr CreateBFromUnique（std:：unique\u ptr a）{
返回MakeUnique（std:：move（a））；
}
int main（）{
auto b=CreateBFromUnique（MakeUnique（））；
}

……您也可以考虑从<代码> < < /代码>中导出<代码> TyBuff.<代码>，以使<代码> t>代码>易于提取，如“代码>类型名称U::ValueEyType .< /P> < P> >当然有不止一种方法，但是…
#include <memory>

template <typename T> T AtypeHelper(A<T>*){}
template <typename T>
using Atype = decltype(AtypeHelper((T*)0));

template <typename U, typename T = Atype<U>>
  std::unique_ptr<B<T>> CreateBFromUnique(std::unique_ptr<U> a) {
  return MakeUnique<B<T>>(std::move(a));
}

int main() {
    auto b = CreateBFromUnique(MakeUnique<Aint>());
}

#包括
模板T AtypeHelper（A*）{}
模板
使用Atype=decltype（atypeheloper（（T*）0））；
模板
std:：unique\u ptr CreateBFromUnique（std:：unique\u ptr a）{
返回MakeUnique（std:：move（a））；
}
int main（）{
auto b=CreateBFromUnique（MakeUnique（））；
}

……您也可以考虑从<代码> < < /代码>中导出<代码> TyBuffF以使<代码> t>代码>易于提取，如“代码>类型名U::ValueSyType .P/>