Why is template argument deduction/substitution failing for function templates only?

Question

I'm experimenting with a class which is a wrapper of multiple modules. Each module needs some configuration. I try to solve this with a variadic template functions to ensure at compiletime, that each module which should be generated has it's configuration data given.

The only problem left is that the template argument deduction/substitution is failing for my creation function template. If the whole wrapper would be a templated class it would work.

Following I'm providing a little example of the problem. I tried to keep it as simple as possible.

class ClassA{};
class ClassB{};

template<class Module>
class FactoryModuleConfig;

template<>
class FactoryModuleConfig<ClassA>{
    public:
    FactoryModuleConfig(){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
    virtual ~FactoryModuleConfig(){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
};
template<>
class FactoryModuleConfig<ClassB>{
    public:
    FactoryModuleConfig(){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
    virtual ~FactoryModuleConfig(){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
};

template< class... Args >
class FactoryConfig;

template<class Arg, class... Args>
class FactoryConfig<Arg, Args...> : public FactoryModuleConfig<Arg>, public virtual FactoryConfig<Args...>
{
    public:
        FactoryConfig(){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
        virtual ~FactoryConfig( ){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
};

template<>
class FactoryConfig<>
{
    public:
        FactoryConfig(){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
        virtual ~FactoryConfig( ){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
};

class myFactoryConfig : public FactoryConfig<ClassA,ClassB>{
 public: 
    myFactoryConfig(){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
    virtual ~myFactoryConfig( ){ std::cout << __PRETTY_FUNCTION__ << std::endl; }
    int getNumberOfModules() const { return 1; } 
};

class Factory{
        Factory(){}
    public:
        virtual ~Factory(){}

        template<class ...Args>
        static Factory* create(FactoryConfig<Args...>* pCfg){ return new Factory();}
};

template<class ...Args>
class Factory2{
    public:
        Factory2(FactoryConfig<Args...>* pCfg){}
        virtual ~Factory2(){}
};

int main()
{
    // Solution 1
    myFactoryConfig* pCfg = new myFactoryConfig();                      // <-- why is this not working 
    // FactoryConfig<ClassA,ClassB>* pCfg = new myFactoryConfig();      // <-- and this works like a charm
    Factory* pfac = Factory::create<ClassA,ClassB>(pCfg);

    // Solution 2                                                       // Solution 2 is always working
    //FactoryConfig<ClassA,ClassB>* pCfg = new myFactoryConfig();       
    //Factory2<ClassA,ClassB>* pfac = new Factory2<ClassA,ClassB>(pCfg);  

    delete pfac;
    delete pCfg;

    return 0;
}

Here is the example at coliru: https://coliru.stacked-crooked.com/a/744c58c7025c1c2f

I'm starting to doubt my c++ knowledge...

`new Factory2` succeeds because *there isn't deduction*, you *must* specify all the parameters for the class template, so there can't be trailing `Args...` — Caleth, Oct 26 '18 at 13:48

Holt · Accepted Answer · 2018-10-26T13:20:41.423

3

Solution without explanation as the previous one was incorrect, stil digging...

You can solve this by making FactoryConfig only inherits FactoryModule<>:

template< class... Args >
class FactoryConfig: public FactoryModuleConfig<Args>...
{
    public:
        FactoryConfig() { std::cout << __PRETTY_FUNCTION__ << std::endl; }
        virtual ~FactoryConfig() { std::cout << __PRETTY_FUNCTION__ << std::endl; }
};

edited Oct 26 '18 at 13:20

answered Oct 26 '18 at 13:08

Holt

36,600
7
92
139

Or as the Args are not relevant, just use a non variadic template `template static Factory* create(Config* pCfg)` – Matthieu Brucher Oct 26 '18 at 13:11
@MatthieuBrucher I assumed this part of the code was simplified by OP for the question, otherwise I don't see a point in having this function templated, but this would be a good approach if `Args` are irrelevant. I still think that having a more flat hierarchy would be beneficial here. – Holt Oct 26 '18 at 13:14
True enough. Still odd to have all these virtual calls with templates at the same time. I would have assumed either ones would be enough. – Matthieu Brucher Oct 26 '18 at 13:15
Actually, as `Args` is specified, there should not be any confusion for the compiler as to which `create` to call. – Matthieu Brucher Oct 26 '18 at 13:18
@MatthieuBrucher Yes, I mixed up something while writting this answer... I've removed the explanation part and kept the solution as I think it's relevant anyway... Going to dig a bit deeper for the explanation! – Holt Oct 26 '18 at 13:21
As @Holt already stated, the part about the Args was simplified. – theBro Oct 26 '18 at 22:56
Thanks a lot @Holt, without doubt this a better solution for my problem. I'm gonna use it! I would still be interested in why this specific constellation does not work. – theBro Oct 26 '18 at 23:01
@theBro It might be a bug in gcc as other people have suggested. Since you've specified ``, the deduction is equivalent to `create(FactoryConfig *)`, which works with gcc... I've reduced your example to something more minimal https://godbolt.org/z/2I7cBU, maybe it's worth opening a bug or looking for a similar one. – Holt Oct 29 '18 at 10:47

score 1 · Answer 2 · answered Oct 26 '18 at 13:14

1

Compiles fine under clang, possibly a bug in gcc? See g++ c++17 class template argument deduction not working in a very specific case for a vaguely similar example.

answered Oct 26 '18 at 13:14

This should really be a comment, and potentially flag it as a duplicate. As is this isn't really an answer. – NathanOliver Oct 26 '18 at 13:16
Indeed, seems like a gcc bug. – Matthieu Brucher Oct 26 '18 at 13:17
While this might be a bug (I have to dig through the standard), the linked answer is about class template argument deduction, which is irrelevant here. – Holt Oct 26 '18 at 13:18
Probably not the same bug, the linked bug involved parentheses. – Oct 26 '18 at 13:18
I mostly linked it for the answer that says "This is a brand new feature in C++17, and therefore brand new in GCC." – Oct 26 '18 at 13:19
@jakub_d Template argument deduction for functions is not something new. – Holt Oct 26 '18 at 13:20

Why is template argument deduction/substitution failing for function templates only?

2 Answers2