CODEWITHSUNDEEP
c++classoopinheritancefactory
Kaspie
Kaspie

Reputation: 187

Base class undefined, but its header is included

I'm having some troubles where a function isn't returning the right type, because a class isn't defined. I'm using a factory pattern.

The two error messages that I'm getting are:

'return': cannot convert from 'DLA *' to 'Layer *'

and:

'Layer': base class undefined (compiling source file src\Layer.cpp)

and this same error message is repeated for every file that includes Layer.h.

Here is what my class that inherits from Layer looks like (DLA.h):

#pragma once

#ifndef _DLA
#define _DLA

#include "ofMain.h" 
#include "ofxGui.h"
#include "Layer.h"

class DLA: public Layer
{
public:
    DLA();
    void setup();
    void update();
    void draw();

private:
};

#endif

and here is my Layer class header (Layer.h):

#pragma once

#ifndef _LAYER
#define _LAYER

#include "ofMain.h" 
#include "ofxGui.h"
#include "DLA.h"

enum SceneType
{
    Scene_None,
    Scene_Default,
    Scene_DLA,
};

class Layer
{

public:

    void setup();
    void update();
    void draw();
    static Layer *CreateSimulation(SceneType Type);


private:
};

#endif

The function which is failing is this one, situated in Layer.cpp:

Layer *Layer::CreateSimulation(SceneType Type)
{
    switch (Type)
    {
    case Scene_None:
    default:
        return nullptr;
    case Scene_DLA:
        return new DLA();
    }
}

I've tried everything I could find on Stack Overflow that had similar issues to mine but I've seen some people recommend very subtle code indentation to fix this, so I'm really lost as to find where the problem is.

enter image description here

Upvotes: 4

Views: 1748

Answers (1)

Adrian Mole
Adrian Mole

Reputation: 51815

As they stand, your header files induce circular dependency, even though the #pragma once (and other) guards prevent any actual 'infinite recursion'. Let's look at the sequence of code, from the compiler's point-of-view, when compiling the Layer.cpp file (or any other '.cpp' source that has #include "Layer.h" in it).

The compiler encounters #include "Layer.h" (the first time it has done so - the guards won't be 'triggered'), so it duly replaces that line with the contents of the indicated header. In that content, it encounters #include "DLA.h" (we can ignore the other headers included in this discussion, assuming that they aren't relevant to the problem in hand). So, it then duly replaces that line with the contents of the DLA.h header, at which point it will come across this:

#include "Layer.h"

class DLA: public Layer
{

Now, here, when it replaces #include "Layer.h" with the header content, that content will be 'empty' (because of the guards, as it has already included that header once). Thus, when the public Layer code is encountered, it is an error, because that class has not yet been defined, or even declared as a class.

So, if you really insist on having the #include "DLA.h" line in Layer.h, then it must be placed after the definition of the Layer class.

However, a far better way would be to remove #include "DLA.h" from Layer.h, and only place it in source (.cpp) files that actually need it (like Layer.cpp). This would work well:

// Layer.cpp
#include "Layer.h"
#include "DLA.h"   // At this point, references to the Layer class in DLA.h will be fine!

//...

Layer *Layer::CreateSimulation(SceneType Type)
{
    switch (Type)
    {
    case Scene_None:
    default:
        return nullptr;
    case Scene_DLA:
        return new DLA();
    }
}

Feel free to as k for any further clarification and/or explanation.

Upvotes: 2

Related Questions