基于返回类型的函数模板推导？

Question

我希望能够使用模板推演来实现以下目标：

GCPtr<A> ptr1 = GC::Allocate();
GCPtr<B> ptr2 = GC::Allocate();

而不是（我目前拥有的）：

GCPtr<A> ptr1 = GC::Allocate<A>();
GCPtr<B> ptr2 = GC::Allocate<B>();

我当前的分配函数如下所示：

class GC
{
public:
    template <typename T>
    static GCPtr<T> Allocate();
};

这是否可以取消额外的<A> 和<B>？

Answer 1

那是做不到的。返回类型不参与类型推导，而是已经匹配了适当的模板签名的结果。但是，您可以将其从大多数用途中隐藏起来：

// helper
template <typename T>
void Allocate( GCPtr<T>& p ) {
   p = GC::Allocate<T>();
}

int main()
{
   GCPtr<A> p = 0;
   Allocate(p);
}

该语法实际上是否比最初的 GCPtr<A> p = GC::Allocate<A>() 更好或更差是另一个问题。

附： c++11 将允许您跳过其中一种类型声明：

auto p = GC::Allocate<A>();   // p is of type GCPtr<A>

Answer 2

我唯一能想到的就是：让 Allocate 成为一个非模板，它返回一个非模板代理对象，该对象具有一个模板化的转换运算符，它可以完成真正的工作：

template <class T>
struct GCPtr
{

};

class Allocator
{
public:
    template <class T>
    operator GCPtr<T>() { return GCPtr<T>(); }
};

class GC
{
public:
    static Allocator Allocate() { return Allocator(); }//could give a call-back pointer?
};

int main()
{
    GCPtr<int> p = GC::Allocate();
}

Answer 3

你可以走相反的路线。

如果您使用的是最新的编译器（MSVC 2010 应该会在几天后发布，或者当前版本的 GCC）并且不介意依赖 C++0x 功能：

auto ptr1 = GC::Allocate<A>();
auto ptr2 = GC::Allocate<B>();

会为您节省额外的 <A> 和 <B>，只是不在右侧。 :)

Answer 4

（此答案与@UncleBens 相同，但更通用一点，因为它可以完美转发任何参数。）

这在 haskell 等语言中非常有用，例如，read 将字符串作为输入，并根据所需的返回类型对其进行解析。

（这里是sample code on ideone。）

首先，从函数foo开始，我们希望推断其返回类型：

template<typename Ret>
Ret foo(const char *,int);
template<>
std::string foo<std::string>(const char *s,int) { return s; }
template<>
int         foo<int        >(const char *,int i) { return i; }

当要求输入字符串时，它会返回第一个参数中的字符串。当要求输入 int 时，它会返回第二个参数。

我们可以定义一个函数auto_foo，可以如下使用：

int main() {
        std::string s = auto_foo("hi",5); std::cout << s << std::endl;
        int         i = auto_foo("hi",5); std::cout << i << std::endl;
}

---

为了完成这项工作，我们需要一个对象来临时存储函数参数，并在要求 convert 到所需的返回类型时运行函数：

#include<tuple>

template<size_t num_args, typename ...T>
class Foo;
template<typename ...T>
class Foo<2,T...> : public std::tuple<T&&...>
{
public: 
        Foo(T&&... args) :
                std::tuple<T&&...>(std::forward<T>(args)...)
        {}
        template< typename Return >
        operator Return() { return foo<Return>(std::get<0>(*this), std::get<1>(*this)); }
};
template<typename ...T>
class Foo<3,T...> : std::tuple<T&&...>
{
public: 
        Foo(T&&... args) :
                std::tuple<T&&...>(std::forward<T>(args)...)
        {}
        template< typename Return >
        operator Return() { return foo<Return>(std::get<0>(*this), std::get<1>(*this), std::get<2>(*this)); }
};

template<typename ...T>
auto
auto_foo(T&&... args)
        // -> Foo<T&&...> // old, incorrect, code
        -> Foo< sizeof...(T), T&&...> // to count the arguments
{
        return              {std::forward<T>(args)...};
}

此外，上述方法适用于两个参数或三个参数的函数，不难看出如何扩展它。

要写很多代码！对于您将应用它的每个函数，您可以编写一个宏来为您执行此操作。文件顶部的类似内容：

REGISTER_FUNCTION_FOR_DEDUCED_RETURN_TYPE(foo); // declares
                        // necessary structure and auto_???

然后你可以在你的程序中使用auto_foo。

Answer 5

同样你不能在返回类型上重载函数，你不能对它做模板推导。出于同样的原因 - 如果 f() 是返回某些内容的模板/重载，那么在这里使用什么类型：

f();

Answer 6

您可以尝试使用宏。除此之外，我看不出只用一个语句应该如何工作。

#define ALLOC(ptrname,type) GCPtr<type> ptrname = GC::Allocate<type>()

ALLOC(ptr1,A);

Johannes 的观点是有效的。 >> 问题很容易解决。但我认为将逗号作为类型的一部分需要 C99 预处理器可变参数扩展：

#define ALLOC(ptrname,...) GCPtr< __VA_ARGS__ > ptrname = GC::Allocate< __VA_ARGS__ >()

ALLOC(ptr1,SomeTemplate<int,short>);