Proper use of undefined type in template class inheriting from abstract class

Question

I have a header file (say the_foo.h) which defines/declares the following classes:

// \file the_foo.h

class FooBase
{
    virtual size_t bar_size() = 0;
};

template<class Bar>
class Foo : public FooBase
{
    size_t  bar_size()  { return sizeof(Bar); }
};

class TheBar;       // TheBar forward declaration

class TheFoo : public Foo<TheBar>
{
};

Compiling with MS vc14 (Visual Studio 2015), I notice the following behaviors:

1. Any cpp file which includes the_foo.h and defines TheBar, eg:

   #include "the_foo.h" class TheBar {}; // TheBar definition

   will compile just fine. However,

2. Any cpp file which includes the_foo.h and DOES NOT DEFINE TheBar, eg:

   #include "the_foo.h"

   fails to compile with error: the_foo.h(11): error C2027: use of undefined type 'TheBar'

   The cpp file compiled above contains one single line: inclusion of the header, no more code.
   Removing the virtual member function declaration virtual size_t bar_size() = 0; does fix the error.
   Thanks to answer from Sam Varshavchik, this code compile fine using gcc 5.3.1, so this issue is clearly compiler specific.

My questions are:

• Why does compilation fail in case (2), when TheBar is forward declared only ?
• Is there any way to make case (2) compiling successfully under vc14, i.e. without an explicit definition of TheBar, which class I need to keep opaque in some cpp files ?

PS: I edited the code sample of this question in order to make clear what actually causes the issue described in the question. The original code sample (which is quoted in the answer from Sam Varshavchik) may indeed have misleaded on the actual cause of the issue and, consequently, leaded to answers and comments out of the question scope.

Answer 1

Your test case compiles without issues with gcc 5.3.1:

$ cat t.C
class FooBase
{
public:
    FooBase()          {}
    virtual ~FooBase() {}
};

template<class Bar>
class Foo : public FooBase
{
public:
    Foo()   { sizeof(Bar); bar = new Bar; }
    ~Foo()  { sizeof(Bar); delete bar; }
    Bar*    bar;
};

class TheBar;

class TheFoo : public Foo<TheBar>
{
public:
    TheFoo();
    ~TheFoo();
};
[mrsam@octopus tmp]$ g++ -c -o t.o t.C
[mrsam@octopus tmp]$ 

The answer here appears to be "you're using an old C++ compiler that does not correctly compile this".

Answer 2

The compiler searches for a definition of the class TheBar when you try to construct or delete it in the constructor and destructor of the Foo class. It means it needs the implementation at that point, otherwise it has no idea what to do.

If make the following example:

The first header:

// foobase.h

class FooBase
{
    public:
        FooBase()          {}
        virtual ~FooBase() {}
};

template<class Bar>
class Foo : public FooBase
{
    public:
        Foo()  { bar = new Bar; }
        ~Foo() { delete bar; }
    private:
        Bar* bar;
};

class TheBar;

class TheFoo : public Foo<TheBar>
{
    public:
        TheFoo() {};
        ~TheFoo() {};
};

The next header

// thebar.h

class TheBar {};

And the following main file:

// foo_main.cxx

// #include "thebar.h" // Including this include makes the program run
#include "foobase.h"

int main()
{
    TheFoo thefoo;
    return 0;
}

Then your compiler will tell you what is wrong (only first error shown):

./foobase.h:14:32: error: allocation of incomplete type 'TheBar'
        Foo()  { bar = new Bar; }

Including thebar.h will solve the problem.