Modelli di classi con nomi duplicati?

Question

È possibile definire due classi differenti (per numero di argomenti del modello) con lo stesso nome?

Qui è quello che sto cercando di fare:

namespace MyNamespace 
{ 

template<class TRet> 
class FunctionObject 
{ 
    typedef typename TRet ReturnType; 
    virtual ReturnType const operator()() const = 0; 
}; 


template<class TRet, class TArg0> 
class FunctionObject 
{ 
    typedef typename TRet ReturnType; 
    typedef typename TArg0 FirstArgumentType; 
    virtual ReturnType const operator()(FirstArgumentType const &arg) const = 0; 
}; 

} 

ottengo un errore di nota troppi argomenti template alla fine della chiusura staffa della seconda definizione FunctionObject struct.

So che questo può essere fatto in C#, ma non ero sicuro di C++. Qualcuno può per favore fare un po 'di luce qui?

Answer 1

Penso specializzazione parziale farebbe il trucco:

namespace MyNamespace { 

    template<class TRet, class TArg0> 
    class FunctionObject 
    { 
     typedef typename TRet ReturnType; 
     typedef typename TArg0 FirstArgumentType; 
     virtual ReturnType const operator()(FirstArgumentType const &arg) const = 0; 
    }; 

    template<class TRet> 
    class FunctionObject<TRet,void> 
    { 
     typedef typename TRet ReturnType; 
     virtual ReturnType const operator()() const = 0; 
    }; 

} 

si potrebbe anche iniziare con un modello primaria con più di un parametro.

Penso che C++ 11 i suoi modelli variadici consentano che questo sia più elegante, ma non avevo avuto il tempo di giocare con questo, quindi è meglio lasciarlo a qualcun altro da mostrare.

Answer 2

credo che qualcosa di simile a questo sarà anche funzionare, ma con classi separate non può essere quello che stai cercando:

namespace MyNamespace 
    { 

     class AbstractFunctionObject 
     { 
     //shared functionality here 
     }; 

     template<class TRet> 
     class ConcreteFunctionObjectA : AbstractFunctionObject 
     { 
     typedef typename TRet ReturnType; 
     virtual ReturnType const operator()() const = 0; 
     }; 


     template<class TRet, class TArg0> 
     class ConcreteFunctionObjectB : AbstractFunctionObject 
     { 
     typedef typename TRet ReturnType; 
     typedef typename TArg0 FirstArgumentType; 
     virtual ReturnType const operator()(FirstArgumentType const &arg) const = 0; 
     }; 

    } 

Answer 3

Penso che si possa farlo funzionare con un modello di classe, fornendo tipo predefinito argomento per il secondo parametro template come:

struct null_type {}; 

template<class TRet, class TArg0 = null_type> 
class FunctionObject 
{ 
    typedef typename TRet ReturnType; 
    typedef typename TArg0 FirstArgumentType; 

    //both functions here 
    virtual ReturnType const operator()() const = 0; 

    virtual ReturnType const operator()(FirstArgumentType const &arg) const = 0; 
}; 

Answer 4

per mostrare suggerito soluzione di modello variadic di SBI:

namespace MyNamespace { 

    template<typename...> FunctionObject; 

    template<class TRet, class TArg0> 
    class FunctionObject<TRet,TArg0> 
    { 
     typedef typename TRet ReturnType; 
     typedef typename TArg0 FirstArgumentType; 
     virtual ReturnType const operator()(FirstArgumentType const &arg) const = 0; 
    }; 

    template<class TRet> 
    class FunctionObject<TRet> 
    { 
     typedef typename TRet ReturnType; 
     virtual ReturnType const operator()() const = 0; 
    }; 

} 

Ora è possibile aggiungere specializzazioni nell'ordine desiderato, senza modificare gli altri modelli (a meno che il numero/tipo di parametri del modello non sia in conflitto).