Passing "this" as function parameter

Hello there,

I'm trying to pass a reference to a current class as a parameter of a method of another class without success.

Say in class foo I call a function in class bar and pass a reference to foo as a parameter.

Here is the prototype in bar:

Code:

---

void someFunction(foo & reference);

---

Here is the call to the function in foo:

Code:

---

myBar.someFunction(this);

---

Why is this not allowed? How can foo pass a reference to itself to bar?

Thanks for your help.

this is a pointer. someFunction expects a reference. I suppose dereferencing this might work.

Quote:

---

Originally Posted by anon

this is a pointer. someFunction expects a reference. I suppose dereferencing this might work.

---

I'm afraid not. The whole point of this is that I need either a reference of a pointer to the calling class... and even if I change my prototype to the following I get the same problem.

Code:

---

void someFunction(foo * reference);

---

Exactly what errors are you getting? Dereferencing this should work in your original case. Your problem may lie elsewhere.

The following error keeps poping up, and it points to my function prototype.

error C2061: syntax error : identifier 'foo'

May-be paste some code?

Has the compiler seen declaration of foo() before you try to call it?

Quote:

---

Originally Posted by pgavigan

The following error keeps poping up, and it points to my function prototype.

error C2061: syntax error : identifier 'foo'

---

I reckon you need a forward declaration.

Try putting this before class bar:

Code:

---

class foo;

---

I have tried that, and with no luck!

Here are some complete classes:

Code:

---

class something {
public:
        something(void);
        ~something(void);

        void someFunction(void){
                awful it;
                it.someFunction(this);
        }
};

---

And another class:

Code:

---

class awful {
public:
        awful(void);
        ~awful(void);

        void someFunction(something & reference) {
                cout << "Something awful happened";
        }
};

---

Wow, I figured it out!

The compiler demands that the prototype have "const" in the parameter list.

Strange.

Thanks for all your help.

And you get an error about identifier foo()?

Firstly, you'll need to pass *this. Secondly, you may need to move awful before something and/or separate method declarations from implementations.

Edit:

Quote:

---

The compiler demands that the prototype have "const" in the parameter list.

Strange.

---

Yes, that is strange, because in awful and something there isn't anything that demands the use of const.

Posting real code helps...

Assuming these are in the same file, arrange them like so:

Code:

---

class something;

class awful {
public:
        awful(void);
        ~awful(void);

        void someFunction(something & reference) {
                cout << "Something awful happened";
        }
};

class something {
public:
        something(void);
        ~something(void);

        void someFunction(void){
                awful it;
                it.someFunction(*this);
        }
};

---

This should work for this silly example. However, if someFunction actually does something with reference, the code for someFunction needs to be moved down so that it is below class something { /* blah */ };

This sort of thing is best arranged across multiple files. I don't know if you're doing that or not, but if not you should consider it.

Here is the working code:

Code:

---

class something;

class awful {
public:
        awful(void){}
        ~awful(void){}

        void someFunction(const something * reference) {
                cout << "Something awful happened";
        }
};

---

Code:

---

class something {
public:
        something(void){}
        ~something(void){}

        void someFunction(void){
                awful it;
                it.someFunction(this);
        }
};

---

Thanks again for your help.

I don't see any reason why that would need const. What compiler are you using?

Yep, doesn't this really compile?

Code:

---

#include <iostream>
using std::cout;

class something;

class awful {
public:
        awful(void){}
        ~awful(void){}

        void someFunction(something *reference) {
                cout << "Something awful happened";
        }
};

class something {
public:
        something(void){}
        ~something(void){}

        void someFunction(void){
                awful it;
                it.someFunction(this);
        }
};

int main()
{
    something s;
    s.someFunction();
    std::cin.get();
}

---

Quote:

---

Originally Posted by AverageSoftware

I don't see any reason why that would need const. What compiler are you using?

---

You're right... my bad, it looks like all that it was complaining about was the lack of a forward declaration. I must have mixed up my tests :).

It is strange though that it needs a forward declaration like that... I haven't mentioned it in my posts up to now, but I have my code in separate files with "#include" references to the other files at the top. Shouldn't the "#include" take care of any requirements for forward declarations?

Quote:

---

Originally Posted by pgavigan

Shouldn't the "#include" take care of any requirements for forward declarations?

---

When you have two classes that refer to each other, that won't work. Consider this:

Code:

---

//class1.h
#include "class2.h"

//end class1.h

//class2.h
#include "class1.h"

//end class2.h

---

This results in files #including each other, which would never end. One of them has to be forward declared, and then you move the #include to the .cpp file.