Inner class accessing outer class [duplicate]

Answer 1

my question is, submachine is a member of FSM, so it should have access to local instances of all the attributes of FSM, no?

No. Unlike in Java, inner class objects don't have an implicit reference to an outer object.

wouldn't we be creating an intance of all its members i.e. submachine?

submachine is a type, not a member variable. If you wanted a member variable, you'd have to do something like this:

struct FSM {
    struct submachine {
        ...
    };

    submachine sm;  // Member variable of type submchine
};

And if you want sm to "see" its parent object, you'll need to pass it explicitly:

struct FSM {
    struct submachine {
        FSM &parent;  // Reference to parent
        submachine(FSM &f) : parent(f) {}  // Initialise reference in constructor
    };

    submachine sm;

    FSM() : sm(*this) {}  // Pass reference to ourself when initialising sm
};

Note that the same principle applies for instances of submachine that aren't member variables. If you want them to be able to access an FSM instance, you'll need to pass a reference to one.

Note also that you could use a pointer rather than a reference. In fact, a pointer offers greater flexibility in many cases.

Answer 2

I am only making a guess at what you want to do, but if my guess is correct, you might be thinking of something like the below.

struct FSM_Base {
    int x;

    struct submachine1;
    struct submachine2;

    FSM_Base () : x(0) {}
    virtual ~FSM_Base () {}
};

struct FSM_Base::submachine1 : virtual public FSM_Base {
    void oneentry () { int g = x; }
};

struct FSM_Base::submachine2 : virtual public FSM_Base {
    void oneentry () { int g = x; }
};

struct FSM : public FSM_Base::submachine1,
             public FSM_Base::submachine2 {
    FSM_Base::submachine1 * sub1 () { return this; }
    FSM_Base::submachine2 * sub2 () { return this; }
};

Answer 3

consider that in your example, I can legally write a free function

void foo()
{
    FSM::submachine sub;
    sub.onentry();
}

where there is no FSM instance that sub could refer to.

Either, as Oli says, have the submachine object store a reference to its parent FSM object, or perhaps just pass the value of x directly into onentry (it isn't clear how it gets invoked).

---

From a quick look at the Boost.MSM docs I found this note on non-default-constructed submachines.

It's pretty ugly, I don't understand the backend enough to paraphrase it here, and the literal code won't make enough sense in isolation to be worth pasting.

The example code linked from there also shows the submachine's entry method with the following signature:

template <class Event,class FSM> void on_entry(Event const&,FSM& );

if that's accurate, you can either store a pointer to your outer state machine on_entry, or extract the value of x there and record it in the submachine.

Answer 4

Note that declaring struct submachine only defines the type; it does not actually create a field in the class of that type.

You would need one of the following:

struct submachine mysub; // creates a field after the class is defined

or

struct submachine
{
  . . .
} mysub; // creates the field "mysub" also, as the structure is being defined

This makes mysub the field, and you then access it in the same way that you'd access x.

The definition of submachine needs to include a specific FSM (e.g. a pointer field FSM*, and probably a constructor like submachine(FSM* fsm): fsm_(fsm) {} to initialize it) so that you can say fsm_->getX() to access a certain X value.