कोड डुप्लिकेशन और टेम्पलेट विशेषज्ञता (जब विशेष फ़ंक्शन में अलग-अलग रिटर्न प्रकार होते हैं)

Question

मैं एक विधि (ऑपरेटर(), इस मामले में एक टेम्पलेटेड क्लास D<N> बना रहा हूं, जो एन के मान के आधार पर विभिन्न प्रकार देता है।

मैं केवल दो अलग-अलग वर्ग घोषणाओं को बनाकर यह काम कर सकता हूं, लेकिन यह बहुत सारे कोड डुप्लिकेशंस की लागत पर आया था। मैं भी में आम सामान फेंकने के लिए एक आम आधार वर्ग बनाने की कोशिश की, लेकिन मैं निर्माता सही वारिस के लिए नहीं मिल सकता है और कैसे मुहावरेदार कि रूप में अच्छी तरह होगा पता नहीं है ...

#include <cstdio> 

template <int N> 
struct D{ 
    int s; 
    D(int x):s(x){} 

    int yell(int x){ 
     printf("N=%d, %d\n", N, s+x); 
     return s+x; 
    } 

    D<N-1> operator()(int x){ 
     D<N-1> d(yell(x)); 
     return d; 
    } 
}; 

template <> 
struct D<1>{ 
    int s; 
    D(int x): s(x){} 

    int yell(int x){ 
     printf("N=%d, %d\n", 1, s+x); 
     return s+x; 
    } 

    int operator()(int x){ 
     return yell(x); 
    } 
}; 


int main() 
{ 
    D<2> f(42); 
    printf("%d\n", f(1)(2)); 
    return 0; 
} 

कैसे क्या मैं अपना कोड बेहतर दिख सकता हूं?

Answer 1

आप उत्सुकता से आवर्ती टेम्पलेट पैटर्न का उपयोग कर सकते हैं।

template<int N, template<int> typename D> struct d_inner { 
    D<N-1> operator()(int x) { 
     return D<N-1>(static_cast<D<N>*>(this)->yell(x)); 
    } 
}; 
template<template<int> typename D> struct d_inner<1, D> { 
    int operator()(int x) { 
     return static_cast<D<1>*>(this)->yell(x); 
    } 
}; 

template <int N> struct D : public d_inner<N, D> { 
    int s; 
    D(int x):s(x){} 

    int yell(int x){ 
     printf("N=%d, %d\n", N, s+x); 
     return s+x; 
    } 
}; 

ऐसा नहीं है कि मैं इस विशेष वस्तु के टेम्पलेट के उपयोगिता या उद्देश्य को देखता हूं, यह आसानी से नहीं हो सकता है।

Answer 2

मैं इसे बेहतर लग रही है यकीन नहीं है: लेकिन यह स्रोत कोड दोहराव से बचा जाता है:

// Find a name for this ... 
template<int N, template<int M> class X> 
struct foo { 
    typedef X<N> type; 
}; 
template< template<int M> class X > 
struct foo<0,X> { 
    typedef int type; 
}; 

template <int N> 
struct D{ 
    int s; 
    D(int x):s(x){} 

    int yell(int x){ 
    printf("N=%d, %d\n", N, s+x); 
     return s+x; 
    } 

    typename foo<N-1,D>::type 
    operator()(int x){ 
    return typename foo<N-1,D>::type(yell(x)); 
    } 
};