Function Template: Access Child Class' Overloaded Function In Base Class - c++

Question

I have a base class First and a derived class Second. In the base class there's a member function create and a virtual function run. In the constructor of Second I want to call the function First::create, which needs access to the implementation of its child class' run() function. A colleague recommended using function templates since First can't know it's child classes explicitly. Sounds weird? Here's some code:
First.h
#pragma once
#include <boost/thread/thread.hpp>
#include <boost/chrono/chrono.hpp>
class First
{
public:
First();
~First();
virtual void run() = 0;
boost::thread* m_Thread;
void create();
template< class ChildClass >
void create()
{
First::m_Thread = new boost::thread(
boost::bind( &ChildClass::run , this ) );
}
};
First.cpp
#include "First.h"
First::First() {}
First::~First() {}
Second.h
#pragma once
#include "first.h"
class Second : public First
{
public:
Second();
~Second();
void run();
};
Second.cpp
#include "Second.h"
Second::Second()
{
First::create<Second>();
}
void Second::run()
{
doSomething();
}
I'm getting an error at First::create<Second>(); saying Error: type name is not allowed. So what's the reason for this error? I assume I didn't quite get the whole mechanics of templates, yet - I'm very new to this topic.

Answer 1

Although you could use CRTP as "suggested" by Kerrek SB and Arne Mertz, here's a solution using a member function template:
class First
{
public:
First();
~First();
virtual void run() = 0;
boost::thread* m_Thread;
// vvvvvvvvvvv this declares a non-template member function `create`
void create(); // (better remove it)
// vvvvvvvvvv this declares a member function template `create`
template< class ChildClass >
void create();
};
For templates, you should provide the definition in the header file, since the definition must be available in every TU where it is required (and not only in one).
The easiest way to do this is to provide the definition of member function templates or members of class templates within the class itself:
class First
{
public:
/* ... */
template< class ChildClass >
void create()
{
// AFAIK, the `bind` is not required
First::m_Thread = new boost::thread(&ChildClass::run,
static_cast<ChildClass*>(this));
}
};
Now, if you want to call this member function template in the Second class, you'd have to explicitly provide the template argument:
void Second::any_function()
{
create<Second>();
}
Some other (possible) issues with your code:
You don't have virtual dtors, therefore deleting a pointer to a base class subobject will invoke UB.
There needs to be a downcast, as &ChildClass::run is of type void (Second::*)().
create is called inside the ctor of Second, which will call Second::run (or whatever template argument you provide), the final override of that function in the class Second. If you override that function in a class derived from Second, that override won't be called in the ctor of Second.
Your dtor of First should either detach or join the boost thread, otherwise std::terminate will be called if the thread is still running when the dtor is called.
run doesn't have to virtual in this example, the exact same code would work w/o run being virtual or even declared in First.

Answer 2

First you have to put template definitions in the header, or the linker will have trouble finding the instantiated templates.
Second: now the pun's done, I assume you derived Second from First<Second>. This is called the "Curiously Recurring Template Pattern" (CRTP).
Since the base class is already specialized and has the type of the derived class carved into its type, there is no need to make any function of it a template (you didn't), and the base class' functions can be just called, without specifying template parameters:
template <class SubClass>
struct First {
void create() {
SubClass& sub = static_cast<SubClass&>(*this);
mThread = make_unique<std::thread>( [&](){sub.run();} );
}
};
struct Second : First<Second> {
Second() { create(); }
void run();
};
Some annotations:
You need not qualify accesses inside First
You can just call create, it's an inherited method, and since Second is no template, there is no need to add qualification or help the compiler with the lookup.
prefer std::thread over boost::thread, it has been in the standard for a while now.
prefer std::unique_ptr over raw pointers with ownership
I prefer lambdas over bind - reads more clear to me.
I made the two classes struct in order to have the member functions public by default and save one line in the example code. There is no difference to class except that.