Implementation File will only recognize forward declaration of other class

Question

I'm having an issue where it appears an implementation file is recognizing only the forward declaration of another class, and not its actual declaration. I've tried using various guards with imports and taking out the forward declaration but to no avail.

Class A has a function "decode" which takes one argument of type B that's defined in a separate file. I'd like to keep all .h's and .cpp's as distinct files. Here they are.

A.h:

class B;
class A{
private:
    string sentence;
public:
    A();
    void decode(const B& decoder);
};

B.h:

class B{
private:
    int code[26];
public:
    B();
    int getCode(int index);
};

A.cpp:

#include "A.h"
A::A(){}
double A::decode(const B& decoder){
    B.getCode(1);
    //other things
}

B.cpp:

#include "B.h"

B::B(){}
int B::getCode(int index){};

and the driver:

#include "B.h"
#include "A.h"
using namespace std;
int main(int argc, char* argv[]){
    B myB;
    A myA;
    myA.decode(B);
}

I'm compiling this with g++ -Wall driver.cpp B.cpp A.cpp, but get hit with an error that looks like:

A.cpp:4 error: invalid use of incomplete type 'const class B'

I've looked through a ton of similar threads trying to find the answer, but nothing has worked for me yet. Any ideas?

Answer 1

Since you are using B's member function getCode in your A.cpp file, the forward declaration only will not suffice as it says nothing about B's member functions. The entire B declaration needs to be available. To do that, include the "B.h" header in your A.cpp file:

#include "B.h"

As pointed out in the comments you should also utilize the header guards for A.h and B.h headers.

Answer 2

Best practice is that every .h file includes everything it needs. That means A.h shall include B.h.

A.h:

#pragma once // Or equivalent include-guard macros
#include "B.h"

class A{
private:
    string sentence;
public:
    A();
    void decode(const B& decoder);
};

B.h:

#ifndef B_h
#define B_h true
class B{
private:
    int code[26];
public:
    B();
    int getCode(int index);
};
#endif 

A.cpp:

#include "A.h"
A::A(){}
double A::decode(const B& decoder){
    B.getCode(1);
    //other things
}

B.cpp:

#include "B.h"

B::B(){}
int B::getCode(int index){};

and the driver:

#include "A.h"

void main(){
    B myB;
    A myA;
    myA.decode(B);
}