How should a member class access to the member functions?

Question

This is a question to find out the better programming practice:

In C++, say I have two classes one of which is a member class of the other, e.g.,

class SomeClass {

 public:

  MemberClass member_class;

  void set_num(double num_) { num_ = num; }

  double num() {return num_; }

 private:

  double num_;

}

I want the member class to have access to the member functions of the outer class, e.g.,

class MemberClass {

 public:

  PrintSquare() {

    cout << num() * num() << endl;

  }

}

I am trying to achieve this in order to reduce the number of function arguments I am passing all around the program.

Answer 1

The most common (and IMHO proper) way to solve this problem is, introducing an interface (or even more interfaces focusing on particular sets of method features) for the containing class, and pass that one to the 'inner' class member on construction:

struct Interface {
  virtual void set_num(double num_) = 0;
  virtual double num() const = 0;
  virtual ~Interface() {}
};

class MemberClass {
public:
    MemberClass(Interface& interface) : interface_(interface) {}
    PrintSquare() {
        cout << interface_.num() * interface_.num() << endl;
    }

private:
    Interface& interface_;
};

class SomeClass : public Interface {
public:
    MemberClass member_class;

    SomeClass() : member_class(*this), num_() {}

    virtual void set_num(double num_) { num_ = num; }
    virtual double num() const { return num_; }
    virtual SomeClass() {}

private:
    double num_;
};

NOTE: Calling methods of the interface though will fail (with a runtime exception), when called from the MemberClass constructor definition.

Answer 2

Although the answer by Kerrek is very interesting, he himself already states this normally isn't the way to go. Common practice would be to make the inner class nested in the outer one, if possible. If the inner one needs access to the outer one in such a way that a nested connection seems natural, this would be the way to go. Construction of an Inner object would then need a reference to the object it is a member from, in order to be able to call functions on its parent:

class Outer
{
    class Inner
    {
        Outer &parent; // consider constness
    public:
        Inner(Outer &_parent); //initializes the parent-reference
        void innerFunction(); // can call members of parent    
    };

    Inner inner;
public: 
    Outer(): inner(*this) { ... } // initialize inner
};

Depending on the standard you're using, the innerFunction now has access to all public members of Outer (C++03), or even all private members as well (C++11). See also this topic: C++ nested classes - inner/outer relationship

EDIT: Did a quick test, and my compiler (gcc 4.7.2) also allows access to private members with older standards. Maybe someone could comment on this...

Answer 3

If your classes are all standard-layout, then you can take advantage of some layout guarantees that C++ makes, namely that a on object of standard layout type may be treated as if it were its own first member. For instance:

struct Foo
{
    int a;

    void barely_legal();
};

struct Bar
{
    Foo x;
    int y;
};

#include <type_traits>

void Foo::barely_legal()
{
    static_assert(std::is_standard_layout<Foo>::value, "Foo");
    static_assert(std::is_standard_layout<Bar>::value, "Bar");

    Bar * p = reinterpret_cast<Bar *>(this);

    ++p->y;
}

This is unusual at best and cruel at worst, so please don't write code like this unless you have a really good reason to do so. (I know people who do have reason to do this, but I don't turn my back towards them.)