Read this, and then read this, it should fix your problems.

Hint: Your code says:

new C(args...))

Where does the variable 'args' come from? Your code doesn't declare any variable by that name.

Bonus hint:

Your template function is still in your .cpp file, despite me saying that was a bad idea.

Non-template functions go in .cpp files, but template functions go in .h files. There are exceptions to that guideline, but learn the guideline itself before worrying about the exceptions.

Unrelated:

After you get your code working, you'll want to look into std::make_unique().

You shouldn't do std::unique_ptr<C>(new C());

It works, but it's less safe and less efficient than std::make_unique().

It works, but it's less safe and less efficient than std::make_unique().

void f(int i, float f){ }
void f(bool b){ }

template<class... Args> void t(const Args&... args)
{
    f(args...);
}

template<class... Bongo> void t(const Bongo&... bingo)
{
    f(bingo...);
}

template<class... Args> void t(const Args&... args)
{
    f(args...);
}

t(10, 23.0f);

// essentially the compiler "generates" (although probably doesn't really)
void t(int i, float f)
{
    f(i, f);
}

Ok, I've changed it to:

// In the header
template <class C, typename... Args>
void addObj(const Args&... args);
// In the .cpp file
template <class C, typename... Args>
void Gui::GuiHandler::addObj(const Args&... args)
{
    container.push_back(std::unique_ptr<C>(new C(args...)));
}

But it still results in the same error :( :

error: statement cannot resolve address of overloaded function

@Servant, I completely forgot to declare args... D: and isn't std::make_unique only for C++14? I'm using C++11.

Bonus hint:
Your template function is still in your .cpp file, despite me saying that was a bad idea.
Non-template functions go in .cpp files, but template functions go in .h files. There are exceptions to that guideline, but learn the guideline itself before worrying about the exceptions.

Bonus hint:
Your template function is still in your .cpp file, despite me saying that was a bad idea.
Non-template functions go in .cpp files, but template functions go in .h files. There are exceptions to that guideline, but learn the guideline itself before worrying about the exceptions.

So, should I make the declaration of the template function in the header file itself? like:

// menuhandler.hpp
class GuiHandler
{
    public:
        std::vector<std::unique_ptr<GuiBase>> container;
        GuiHandler();
        template <class C, typename... Args>
        void Gui::GuiHandler::addObj(const Args&... args)
        {
            container.push_back(std::unique_ptr<C>(new C(args...)));
        }
        void drawElements(sf::RenderWindow& window); 
};

?

Nevermind, it now compiles/links without any errors

All I had to do to remove that error by changing:

guiHandler.addObj<Gui::Button, 10.f, 20.f, 25.f, 25.f, "Button_1", MainFont, 30u>;

to:

guiHandler.addObj<Gui::Button>(10.f, 20.f, 25.f, 25.f, "Button_1", MainFont, 30u);

Tho, a new error appeared. But I managed to fix it by changing some things in the constructor of Gui::Button

std::make_unique<> is, however, not any more efficient. That's different from std::make_shared which is more efficient (by doing the whole allocation in a single call instead of allocating the object and its bookkeeping structure in two calls).

Oops, you're right. A unique pointer doesn't need the shared data struct. Thanks for the correction!

I've used custom deleters for std::unique_ptr before, but never realized std::make_unique didn't provide an interface for it.

@louie999: Congrats on getting it working!

The things in the <> brackets are what get used to generate a real function from the template function.

The things in the () brackets are what get passed to the function after its been generated.

#include <iostream>
using namespace std;

template<typename Type, int FixedTemplatedValue>
void TemplatedFunc(Type value)
{
	std::cout << "Fixed templated value: " << FixedTemplatedValue
	          << "\tPassed in changable value: " << value << std::endl;
}

int main()
{
	auto FuncSeventeen = &TemplatedFunc<std::string, 17>;
	auto FuncTwoHundred = &TemplatedFunc<float, 200>;
	
	//NOTE: These functions always print "17" as their fixed value, 
	//because it's now BUILT INTO the function.
	//They also always take a std::string as their first parameter, because it's BUILT IN at compile time,
	//but they let you decide at run time what the value of that string is.
	FuncSeventeen("Meow");
	FuncSeventeen("Purr"); 
	
	//NOTE: These functions always print "200" as their fixed value, 
	//because it's now BUILT INTO the function.
	//They also always take a float as their first parameter, because it's BUILT IN at compile time,
	//but they let you decide at run time what the value of that float is.
	FuncTwoHundred(0.257f);
	FuncTwoHundred(1.5f);   
	
	return 0;
}

This prints:

Fixed templated value: 17	Passed in changable value: Meow
Fixed templated value: 17	Passed in changable value: Purr
Fixed templated value: 200	Passed in changable value: 0.257
Fixed templated value: 200	Passed in changable value: 1.5

Test it here

When you do:

TemplatedFunc<std::string, 17>("Meow");

It's the same as:

auto FuncSeventeen = &TemplatedFunc<std::string, 17>;
FuncSeventeen("Meow");

The compiler at compile-time creates the function "TemplatedFunc<std::string, 17>" from the template, by passing in the template arguments <std::string> and <17>.

Then, at run-time, the program calls the function, with the function arguments ("Meow").

//std::make_unique implementation (it was forgotten in the C++11 standard, and will be added later).
//Once it's added, I can just remove this function from here.
template<typename T, typename ...Args>
std::unique_ptr<T> make_unique( Args&& ...args )
{
	return std::unique_ptr<T>( new T( std::forward<Args>(args)... ) );
}