Hi guys,

I have a class with a subclass, which is working fine when it is all in-line inside a header file.

If I try to move the subclass to its own source file while leaving a forward declaration (like you would with a function), the compiler throws errors.

Is it not possible to move the subclass into its own CPP file?

Thanks in advance.

class C { ... };
class S;

S myVar; // invalid, the compiler does not know anything about S, not even how much memory it needs
S* myPointer; // no problem, a pointer or reference to an opaque type is fine
C* myBasePointer = myPointer; // invalid, the compiler has no knowledge of any relation between C and S at this point

class Base { ... };

class Derived: public Base { ...};

#include "x.h"
Base::Base() ...

#include "x.h"
Derived::Derived() ...

#pragma once

class One
{
	int doSomething()
	{
		cTwo = new Two();
		return 0;
	}

	class Two;
	Two* cTwo;
};

// Sub class of 'One'
class One::Two
{
	int test()
	{
		return 0;
	}

}; 

#pragma once

class One
{
public:
	int doSomething()
	{
		cTwo = createTwo();
		return 0;
	}

	class Two;
	Two* cTwo;

private:
        Two* createTwo();
};

// Implementation in a different file
class One::Two
{
	int test()
	{
		return 0;
	}

}; 

One::Two* One::createTwo()
{
   return new Two();
}

What you are doing is more used for private implementation when you have multiple implementation of one class based on a macro for cross plateform.

It's also used to hide variables of one class if you implement one private struct.

// test.h
class One
{
	int doSomething()
	{
		cTwo = createTwo();
		return 0;
	}
	
	class Two;
	Two* createTwo();

public:
	Two* cTwo;
};

// test.cpp
#include "test.h"

// Sub class of 'One'
class One::Two
{
public:
	int Two::test()
	{
		return 77;			// return some test value
	}

};

One::Two* One::createTwo()
{
	return new Two();
}

int result = mOne->cTwo->test();