Imagine that you have two classes: MyClassA and MyClassB. Both of these classes have their respective .h and .cpp file. Imagine you need to reference MyClassA in MyClassB, do you know where you should use

#include "MyClassA.h"

and where to use

class MyClassA

in the files of MyClassB?

For example, the code below shows that I'm using

#include "MyClassA.h"

in both header and implementation files of MyClassB:

//This is the header file: MyClassB.h
#include "MyClassA.h" //Including file for MyClassA    

class B{
    public:
        B(){}
        ~B(){};
        //...
}

//This is the implementation file: MyClassB.cpp

#include "MyClassA.h" //Again, including file for MyClassA

//B's methods implementations goes here...

The question is, is this correct?

Simple answer: The implementation file (.cpp) of MyClassB will always need:

#include "MyClassA.h"

However, the header file (.h) of MyClassB does not necessarily need

#include "MyClassA.h"

For example, in the above example, you can replace #include with a forward declaration:

class MyClassA;  //This is a Forward Declaration 

For example:

//This is the header file of class B
class MyClassA; //This is forward declaration   

class B{
    public:
        B(){}
        ~B(){};
        //...
    }

The question is when do you use

#include "MyClassA.h"

vs.

class MyClassA;

I am not a C++ expert, but these are the tips I always keep in mind:

If you are going to invoke the constructor, copy constructor or any method of MyClassA in the header file of MyClassB, then you need to use #include "MyClassA.h".

This is because the compiler needs to know how to create the object or methods belonging to MyClassA. For example:

//This is the header file of class B
#include "MyClassA.h" //Including file for MyClassA    

class B{
    private:
        MyClassA myClass; //You are invoking a constructor of MyClassA

    public:
        B(){}
        ~B(){};

        inline void print(MyClassA myClass){ myClass->print();}; //You are invoking a copy constructor and a method of MyClassA
}

However,

if you have a pointer to MyClassA in MyClassB.h or passing MyClassA by reference in a method argurment, you can simply use the forward declaration instead.

For example:

//This is the header file of class B
class MyClassA; //This is forward declaration    

  class B{
      private:
          MyClassA *myClass; //pointer to MyClassA
      public:
        B(){}
        ~B(){};

        void print(MyClassA* myClass); //Passing by reference. Not calling any methods of MyClassA.
}

So, there you have it. Use #include "MyClassA.h" in the header file of MyClassB.h whenever you will be invoking the constructor or any method of MyClassA. If you are not, you can simply use a forward declaration in the header file of MyClassB.h.

PS. Sign up to my newsletter and get development tips