Duplicación de código y especialización de plantilla (cuando la función especializada tiene diferentes tipos de retorno)

Question

Estoy creando una clase de plantilla D<N>, con un método (operador(), en este caso) que devuelve diferentes tipos, dependiendo del valor de N.

Solo pude hacer que esto funcionara al crear dos declaraciones de clases separadas, pero esto tuvo el costo de una gran cantidad de duplicación de código. También traté de crear una clase base común de tirar las cosas en común, pero no pude conseguir el constructor para heredar la derecha y no sé cómo idiomática que sería así ...

#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; 
} 

Cómo ¿Puedo hacer que mi código se vea mejor?

Answer 1

Puede utilizar el Patrón de plantilla curiosamente recurrente.

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

No es que ver la red- o de un propósito-de este objeto particular que se está templated, que fácilmente podría no serlo.

Answer 2

no estoy seguro de que es mejor buscando: pero evita la duplicación de código fuente:

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