Compiler skipping over variadic template/function in C++

Question

DISCLAIMER - Honestly I am not sure how to frame this question or provide the proper context and would appreciate if people experienced with this problem could recommend what extra information I need to provide to clarify the context. And also if I need to clean up the code section below to make it more legible, I will do that as I receive comments!!

But anyway here goes -

I am trying to work with variadic templates but everytime I compile my code (its on a company codebase) the compiler (gcc 4.8.4 - C++11) seems to skip over all the variadic code section -

TestFactory.cpp

/* 
 * Use this design since Variadic Templates are not available in C++11
 * A MapHolder allows us to create a map of variadic functions.
 */
template <class... Args>
struct MapHolder
{
    static std::map<std::string, NpBaseTest*(*)(Args...)> CallbackMap;
};

template <class... Args>
std::map<std::string, NpBaseTest *(*)(Args...)> MapHolder<Args...>::CallbackMap;

class TestFactory
{
public:
    template <class... Args>
    static void RegisterTest(std::string name, NpBaseTest *(*callback)(Args...));

    template <class... Args>
    static NpBaseTest *CreateTest(const std::string &name, Args &&... args);
};

TestFactory.cpp

template <class... Args>
void TestFactory::RegisterTest(std::string name, NpBaseTest *(*callback)(Args...))
{
    MapHolder<Args...>::CallbackMap[name] = callback;
}

template <class... Args>
NpBaseTest *TestFactory::CreateTest(const std::string &name, Args &&... args)
{
    return (MapHolder<Args...>::CallbackMap[name])(std::forward<Args>(args)...);
}

Calling file -

    void np_test_mgr_print()
    {
        const char *s = "cavpkotest";
        std::string str(s);
        TestFactory::RegisterTest(str.c_str(), &CavPkoTest::create);
        NpBaseTest *o1{TestFactory::CreateTest<uint16_t>(str.c_str(), 1)};
        /* Irrelevant code section */
        NpTestMgr::get_instance().insert(o1);
        NpTestMgr::get_instance().submit();
    }
}

When I compile this (gcc 4.8.4) the object file TestFactory.o is empty. If I do this outside our codebase (gcc 4.4.6) the code is compiled and outputs -

[common]$ nm TestFactory.o | c++filt $1 | grep CreateTest
34:0000000000401d6a W NpBaseTest* TestFactory::CreateTest<unsigned short>(std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, unsigned short&&)
[common]$ nm TestFactory.o | c++filt $1 | grep RegisterTest
35:0000000000401d40 W void TestFactory::RegisterTest<unsigned short>(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, NpBaseTest* (*)(unsigned short))

Answer 1

Templates are only instantiated on use. Putting the definition in an implementation without using them in that file will lead to no instantiation. Then, when you try to use it elsewhere, it will find no implementation to instantiate since it's in an implementation file that the current translation unit can't see. You should leave the implementation in the header. See this question.

Your example works fine if have a definition for NpBaseTest and if you move all of the code in a header (TestFactory.h I assume). Here is an example of how to use the code in your example. Notice that the way your templates are written, they only accept pointers to functions that return NpBaseTest*.

// main.cpp
#include "TestFactory.h"
#include <iostream>

NpBaseTest* test_callback(int x, int y)
{
    std::cout << "Called test_callback(" << x << ", " << y << ")\n";
    return nullptr;
}

int main()
{
    // This instantiates TestFactory::RegisterTest<int, int>
    TestFactory::RegisterTest<int, int>("my test", &test_callback);

    // This instantiates TestFactory::CreateTest<int, int>
    NpBaseTest * result = TestFactory::CreateTest<int, int>("my test", 5, 10);

    return 0;
}

I've written the template parameters explicitly for clariy. In your case, the compiler will be able to deduce these parameters, and the example is greatly simplified. You can simply call the templated methods without any arguments and they will be deduced from the arguments.

// main.cpp
#include "TestFactory.h"
#include <iostream>

NpBaseTest* test_callback(int x, int y)
{
    std::cout << "Called test_callback(" << x << ", " << y << ")\n";
    return nullptr;
}

int main()
{
    // This instantiates TestFactory::RegisterTest<int, int>
    TestFactory::RegisterTest("my test", &test_callback);

    // This instantiates TestFactory::CreateTest<int, int>
    NpBaseTest * result = TestFactory::CreateTest("my test", 5, 10);

    return 0;
}

That's it. If try this example, you will see that symbols for TestFactory::RegisterTest<int, int> and TestFactory::CreateTest<int, int> are now generated.