Classes, pointer to itself to access from a child class

I have a main class with some child classes inside, I need to be able to access other child classes from a child one or members from the main class like the dosomething() function in the example.
How could I initialise the child classes when the main class is created passing an argument to each one pointing their parent class?

Thanks in advance

Code:

---

class subExample {
        mainExample *classParent;
        int i,j;
        int dosomething() {
                i = i+j+24;
                parent->doAnotherThing();
        }
        subExample(mainExample *parent) {
                classParent = parent;
        }
};

class mainExample {
        subExample childClass;

        int doAnotherThing() {
                etc
        }
};

---

What I think you're asking for is this. If this doesn't answer your question, please elaborate.

Code:

---

class SmallComponent {
private:
    BigThing *outer;
public:
    SmallComponent(BigThing *outer) : outer(outer) {}
};

class BigThing {
private:
    SmallComponent small;
public:
    BigThing() : small(this) {}
};

---

By the way, that's a bidirectional dependency (each class is depending on the other), which is very tight coupling. In short, it's not a good idea. Maybe you can explain in more detail what you're trying to do, and why.

The parent could have a manager and the child function can return a value that tells the parent manager if it needs to run another child function or one if its own (parent) functions next. Changing the parent inside the child class sounds dangerous.

ex:

Code:

---

class subExample {
      private:
        int i,j;
      public:
        int dosomething();
};

int subExample::dosomething()
{
  i = i+j+24;
  return i;
}

class mainExample {
      private:
        subExample childClass;
      public:
        void Manager();
        int doAnotherThing(int i);
};

int mainExample::doAnotherThing(int i)
{
  i += 10;
  return i;
}

void mainExample::Manager()
{
  int temp;
  temp = childClass.dosomething();
  if(temp == 24)
    temp = doAnotherThing(temp);
}

---

@dwks
My compiler wouldn't even compile that example because it gets to class smallcomponent and doesn't know what a bigthing is yet because it hasn't been declared. I wasn't aware there was a way to use two classes not dependant on the order they were declared.

That was what I meant, I'm doing a file transferring project in order to archive some experience socket programming, the program has an individual class for each connection, and each connection has some classes, one storing the window class for that connection (Gtk) to modify visual values and a class to control the connection.
What would be the best option to do that?

Code:

---

class SmallComponent {
private:
    BigThing *outer;
public:
    SmallComponent(BigThing *outer) : " outer(outer) {}" -> Here, why are you doing that?
};

---

Quote:

---

Originally Posted by Lesshardtofind

@dwks
My compiler wouldn't even compile that example because it gets to class smallcomponent and doesn't know what a bigthing is yet because it hasn't been declared.

---

Easily dealt with using a forward declaration.

Quote:

---

Originally Posted by lautarox

Code:

---

class SmallComponent {
private:
    BigThing *outer;
public:
    SmallComponent(BigThing *outer) : " outer(outer) {}" -> Here, why are you doing that?
};

---

---

The stuff after the semicolon and before the first open bracket is part of the initializer list. It is the preferred method of initialization of member variables. Instead of:

Code:

---

class bar
{
    int a;
    double b;
    char c;
public:
    bar()
    {
        a = 10;
        b = 45.5;
        c = 'c';
    }
};

---

The preferred method would look like:

Code:

---

class bar
{
    int a;
    double b;
    char c;
public:
    bar() :a(10), b(45.5), c('c') {}
};

---

Is it possible to compile under g++?
I've tryied compiling this with no success

Code:

---

#include <iostream>
using namespace std;

class SmallComponent {
private:
    BigThing *outer;
public:
    void sumar() {
        int x = outer->i+outer->j;
        cout << x << endl;
    }
    SmallComponent(BigThing *outer) : outer(outer) {}
};

class BigThing {
private:
    SmallComponent small;
public:
    doSomething() {
        small.sumar();
    }
    int i;
    int j;
    BigThing() : small(this), i(2), j(4) {}
};


int main() {
        BigThing clase;
        clase.doSomething();
        return 0;
}

---

It returns:
http://img684.imageshack.us/img684/2466/compile.jpg
Sorry for the image link, I can't copy it

Quote:

---

Originally Posted by lautarox

Is it possible to compile under g++?

---

You need to fix several problems, including the fact that you cannot actually use what the BigThing member pointer points to until after the BigThing class is defined, thus you cannot define those two member functions of SmallComponent in the class definition of SmallComponent.

Just to get your example to compile, try:

Code:

---

#include <iostream>

class BigThing;

class SmallComponent {
public:
    SmallComponent(BigThing* outer);
    void sumar();
private:
    BigThing* outer;
};

class BigThing {
public:
    int i;
    int j;

    void doSomething() {
        small.sumar();
    }

    BigThing() : i(2), j(4), small(this) {}
private:
    SmallComponent small;
};

SmallComponent::SmallComponent(BigThing* outer) : outer(outer) {}

void SmallComponent::sumar() {
    using namespace std;
    cout << (outer->i + outer->j) << endl;
}

int main() {
    BigThing clase;
    clase.doSomething();
    return 0;
}

---

Thanks! that was what I was looking for