अपने रिटर्न प्रकार के आधार पर फ़ंक्शन के लिए टेम्पलेट कटौती?

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(); 
}; 

अतिरिक्त < ए> और < बी> को बंद करना संभव होगा?

धन्यवाद

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>() से बदतर है एक और सवाल यह है: आप, फिर भी, इसे के रूप में ज़्यादातर उपयोग से छुपा सकते हैं।

पीएस सी ++ 11 आपको एक प्रकार की घोषणाओं को छोड़ने की अनुमति देगा:

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

Answer 2

आप इसके लिए मैक्रो का उपयोग करने का प्रयास कर सकते हैं। इसके अलावा, मैं नहीं देखता कि इसे केवल एक कथन के साथ कैसे काम करना चाहिए।

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

ALLOC(ptr1,A); 

जोहान्स के अंक मान्य हैं। >> मुद्दा आसानी से तय किया गया है। विस्तार varargs लेकिन मैं होने के लिए अल्पविराम लगता है के रूप में प्रकार का हिस्सा C99 पूर्वप्रक्रमक की आवश्यकता है:

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

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

Answer 3

उसी तरह आप वापसी प्रकार पर कार्य करता है ओवरलोड नहीं कर सकता है, तो आप उस पर कटौती टेम्पलेट नहीं कर सकते। और इसी कारण से - अगर च() एक टेम्पलेट/अधिभार कि कुछ देता है, किस प्रकार का उपयोग करने के लिए यहाँ:

f(); 

Answer 4

केवल एक चीज मैं के बारे में सोच सकते हैं: एक गैर टेम्पलेट है कि एक गैर रिटर्न का आवंटन करना -टेम्प्लेट प्रॉक्सी ऑब्जेक्ट जिसमें एक टेम्पलेटेड रूपांतरण ऑपरेटर है जो वास्तविक कार्य करता है:

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 5

आप विपरीत मार्ग पर जा सकते हैं।

आप (कुछ दिनों के, या जीसीसी के वर्तमान संस्करण में बाहर किया जाना चाहिए जो MSVC 2010) और C++ 0x सुविधाओं पर निर्भर कोई आपत्ति नहीं है तारीख संकलक अप करने के लिए एक प्रयोग कर रहे हैं:

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

आपको अतिरिक्त <A> और <B> बचाएगा, बस दाईं तरफ नहीं। :)

Answer 6

(इस उत्तर @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 इस्तेमाल कर सकते हैं।