Accessing a variable from an unrelated function in C++

Question

I want to access a variable of one class into another class, and set it to some value, e.g. like in code here, i wanna set the some_flag to true in the secondClassFunction(). Is it possible? If yes, how to do it?

Constraints due to system architecture:

The two classes are not inheritable.
The two classes are not related either.
The function signatures of secondClassFunction()cannot be changed.

Here's the code snippet:-

#include <iostream>
using namespace std;

class FirstClass{
    bool some_flag;
    public:
        void setFlag(bool flag);
        bool getFlag();
};

FirstClass::FirstClass(){
    some_flag(false);
}

class SecondClass{
    public:
        void secondClassFunction();
}

SecondClass::secondClassFunction(){
    // do something here.

    // I want to access some_flag using SecondClass object.
    // how to do this?
}

int main() {
    SecondClass secObj;
    secObj.secondClassFunction();
    return 0;
}

Will wrapper classes help? If yes, how?

EDIT:-

Constraint 4. Cannot make the classes friend functions.

Constraint 5. Cannot globalize the flag variable.

Details:-

The flag is set in a function which is a member of FirstClass. I wish to reset this flag in a function which is member of the SecondClass. The two classes are not related, inheritable, and their access specifiers cannot be changed, due to constraints of the system architecture.

The flag is like a semaphore, it's used by multiple tasks, to denote the status of an activity, such as, whether the processor has received a certain command from a mobile app or not.

@sleeptightpupper no, `friend` is your *enemy*. Proper design is your friend. — n. m. could be an AI, May 29 '16 at 06:50
In order to help we'll need some more details on your problem. In particular: Where does the instance of FirstClass come from? What does some_flag do? Why are you unable to change anything about either class? — bdonlan, May 29 '16 at 07:06

Teivaz · Answer 1 · 2016-05-29T07:45:47.307

It seems that you do not care about instance of the FirstClass. So the following approach will work for you:

void SecondClass::secondClassFunction()
{
    // Create local instance of the object to change
    FirstClass first;
    first.setFlag(true);
}

But it makes no sense at all. You need to know which object to modify. I'd suggest three options:

make instance of FirstClass static, global or singleton and modify it
make some_flag and its setter static
set instance of the FirstClass to context before calling SecondClass::secondClassFunction()

Third option explained:

class FirstClass; // Forward declaration
 class SecondClass
{
...
    FirstClass* firstClassInstance;
...
    void setFirstClassInstanceToModify(FirstClass* first)
    {
        firstClassInstance = first;
    }
...
};

void SecondClass::secondClassFunction()
{
    firstClassInstance->setFlag(true);
}

And call it like this

FirstClass first;
...
SecondClass second;
...
second.setFirstClassInstanceToModify(&first);
second.secondClassFunction();

But make sure to have proper and valid instance before calling secondClassFunction

Accessing a variable from an unrelated function in C++

1 Answers1