Error when using other class' object as argument

Hi,

Let's say I have two classes - A and B. In a public member function of A, I use a B object as argument. I use separate files, so I always include the appropriate .h before the function definition. Even so, my compiler doesn't recognize the objet of 'type B' in my function's declaration... Is there something else I must do for that to work?

Thanks,

Renan M Z Mendes

Post the smallest and simplest program that demonstrates the error.

Did class B include class A, as well?

Maybe this can help you, this should compile with no problems:

Code:

---

// FILE: classA.h

class A{

        public:
       
                void test_B(B);
       
        private:
       
};

void A::test_B(B obj){
       
        std::cout << obj.get_letter() << "\n";
}

---

Code:

---

// FILE: classB.h

class B{

        public:
       
                B(char l) : letter(l) {};
               
                char get_letter(){ return letter; };
       
        private:
       
                char letter;
};

---

Code:

---

// FILE: main.cpp

#include <iostream>

#include "classB.h"
#include "classA.h"

int main(){

        B objB('k');
       
        A objA;
       
        objA.test_B(objB);
       
        return 0;
}

---

Note that it's usually a good idea to put descriptive names for the arguments in both declarations, definitions and implementations. Keep them consistent.

Quote:

---

Maybe this can help you, this should compile with no problems:

---

Yes, but it is very fragile:
1. No header inclusion guards.
2. Lack of forward declaration of B in classA.h so classB.h must be included before classA.h

Quote:

---

Originally Posted by laserlight

2. Lack of forward declaration of B in classA.h so classB.h must be included before classA.h

---

Should you always declare B in A? I usually just keep track of the order of my header files, is this wrong? I always use the inclusion guards (except in my quick replies in the forum, lol!)

But seriously, should you always have the forward declaration?

Quote:

---

Originally Posted by dudeomanodude

Should you always declare B in A? I usually just keep track of the order of my header files, is this wrong? I always use the inclusion guards (except in my quick replies in the forum, lol!)

But seriously, should you always have the forward declaration?

---

Good thing - when header order is not important
So yes - I prefer forward declaration when needed

And includ of other headers, when forward declaration is not enough

Quote:

---

Should you always declare B in A? I usually just keep track of the order of my header files, is this wrong?

---

If you want to keep them as separate header files then there should be a forward declaration of B in classA.h so that classA.h can be included on its own. Otherwise it would make sense to just combine the two header files instead of having to keep track of the order of their inclusion.

EDIT:
Actually, I am wrong. You do not have a reference or pointer to B in classA.h, so actually classA.h should include classB.h, not use a forward declaration.

Quote:

---

Originally Posted by laserlight

EDIT:
Actually, I am wrong. You do not have a reference or pointer to B in classA.h, so actually classA.h should include classB.h, not use a forward declaration.

---

9 out of 10 times though you would be right, as one class of mine probably would have a reference or pointer to another class (unlike my little example).

Would you mind editing my example above with I guess just passing B by reference and showing how you would write the includes?

Quote:

---

Would you mind editing my example above with I guess just passing B by reference and showing how you would write the includes?

---

I would just write:

Code:

---

#ifndef CLASS_A_H_
#define CLASS_A_H_

#include "classB.h"

class A{

        public:
       
                void test_B(B);
       
        private:
       
};

void A::test_B(B obj){
       
        std::cout << obj.get_letter() << "\n";
}

#endif

---

classB.h is already self contained so it would only need header inclusion guards.

Of course, I probably would not go about implementing the member functions in the headers, but as you say these are examples.

Thanks laserlight, so does that mean you wouldn't have to include classB in main then? Or would it not matter thanks to the inclusion guards?

Quote:

---

Thanks laserlight, so does that mean you wouldn't have to include classB in main then? Or would it not matter thanks to the inclusion guards?

---

Since classA.h indirectly includes classB.h you would not have to include classB.h in main.cpp, but as you noted with header inclusion guards it does not matter so you should just include classB.h since main.cpp uses B objects.

Quote:

---

Originally Posted by laserlight

Since classA.h indirectly includes classB.h you would not have to include classB.h in main.cpp, but as you noted with header inclusion guards it does not matter so you should just include classB.h since main.cpp uses B objects.

---

So if the includes in main were to look like:

Code:

---

#include "classA.h"
#include "classB.h"

---

At which point is classB.o built? When classA.h is read? When it gets to classB.h in main?

Object files are source files, not headers.
So regardless how many headers you include and where and how, you don't generate an object file.
It will be generated once the compiler processes the B.cpp.

Hi,

Thanks for your replies, people.

Each class does use the other, having functions with the other class' objects as arguments.

I've read through your answers but I haven't quite understood how the whole forward declaration works. Can someone elaborate a little bit more for me? Thanks.

Quote:

---

I've read through your answers but I haven't quite understood how the whole forward declaration works. Can someone elaborate a little bit more for me? Thanks.

---

This would be a forward declaration of B followed by a definition of A where A has a member pointer to B:

Code:

---

class B;

class A
{
public:
    // ...
private:
    B* b;
};

---

The idea is that A does not need the definition of B since it only uses a pointer (or a reference) to B. It also allows one to include A's header in B's header if B's definition depends on A and needs A's definition.

Thanks, laserlight. That indeed did the trick. I've just declared class B in class A's definition and vice-versa and I was able to compile my application. Thanks again.

Renan M Z Mendes

Just remember that it will only work if class A uses a pointer or reference to B.

Code:

---

class B;

class A
{
public:
        // ...
private:
        B* pb; // works
        B& rb; // works
        B bb; // doesn't work
};

---

Actually, I'm not using a B (or A) object as a class member. I'm justing using it as an argument in a member function of the other class. But I'll keep that in mind for future situations. Thanks.

Renan M Z Mendes

It's the same for both arguments and member variables, so no worries there.