Question about design class..

Hi, I have a question about how to design a class.
I am really confused about how objects interact with others.
I know most of the syntax of c++, polymorphism, inhertiance, template as well.
But like others said, knowing syntax do not automatically make u a good programmer.

For eg, if after analysis, I choose to define 10 user define type class A, class B, class C, ..., Class J.

Is it normal if I instance all this objects globally?
That means all if method of A wants to communicate B, it can just directly use global instance b1. Is this acceptable in OOP design?

If I use composition, for example:

Code:

class B {
public:
    void operate() {dosomething;}
private:
    _data of B;
}
class A {
public:
   void method1() {_pb->operate();} 
private:
   B* _pb;
};

Sometimes I confront of situation tat operate() method of B needs to know some data of A in order to operate.

But it can't not.

Then a solution I first think of is to add friendship of class A to B;
Seems a really bad idea.
Then I will try to drag B* _pb out of class A
And instance A a1, B b1, globally.

Code:

void A::method1() {
   b1.operate();  // Call global b1 instance
}

void A::method1() {
   a1.methodxxx() // may need to call a1,too
}

If I confront this. How should I resolve this condition?
If the compsition relation is much larger;
like

Code:

class D {
public:
    void methodD()  { need to know some information about class A ??}  // what should I do?
}
class C {
public:
     void methodC() { _pd->methodD();}
private:
     D* _pd;
}
class B {
public:
    void methodB() {_pc->methodC();}
private:
    C* _pc;
}
class A {
public:
   void methodA() {_pb->methodB();} 
private:
   B* _pb;
};

Does that mean I need to redesign my class?

Originally Posted by ovid

Hi, I have a question about how to design a class.
I am really confused about how objects interact with others.
I know most of the syntax of c++, polymorphism, inhertiance, template as well.
But like others said, knowing syntax do not automatically make u a good programmer.

No, but practice will. You need to take your knowledge of syntax and start writing programs. If you are looking for a way to insure that, without practice, you can acquire/be given enough knowledge to ensure that "everything will be okay" -- no one is going to make that promise. You will make mistakes and have to rethink things. Having to do that will probably help to prevent repeating the mistakes, but I think "the heat of the moment" in programming is such that until you learn a lesson, you are unlikely to see it coming. You will do what you think is the best thing, even if it turns out to be wrong.

Code:

void A::method1() {
   b1.operate();  // Call global b1 instance
}

That will work if object/instance b1 is declared before you even define class A. Since that is not a good plan, here's a better idea:

Code:

void A::method1(B &b1) {
   b1.operate();  // Call global b1 instance
}

Now, you must supply the instance, which must be possible since you will have defined b1before you call A::method1.

Nb., you cannot have method prototypes that explicitly refer to B objects in A, if you also need method prototypes that refer to A objects in B. You can get around this with templates or void pointers.

Originally Posted by ovid

Does that mean I need to redesign my class?

Yeah, a little bit, this is the situation where you will need to use void pointers or templates.

Thx for reply.
this is the situation where you will need to use void pointers or templates..
I don't quite get it.
The class I design I did think they have somewhat "has-A" relationship in it.
Somehow maybe there exists method of inner objects want to use the data member of outside.
I don't know how to use it.
Or does this situation happen imply the class DEFINETELY need to redesign?

Here is your problem:

Code:

class D {
public:
    void methodD()  { need to know some information about class A ??}  // what should I do?
}

You cannot refer to class A until it is defined. So if class A must also explicitly refer to objects of class D, you are stuck.

However, you do not need to use the entire definition. You can just the "forward declarations" for each class. So:

Code:

void A::method1 (D &obj);

can be replaced with:

Code:

template<typename dtype> void A::method1 (dtype &obj);

That is all that needs to happen in the forward declaration. In the definition you can use D specific stuff, eg:

Code:

template<typename dtype> void A::method1 (dtype &obj) {
     obj.someclassDmethod();

In fact, class D does not have to be defined before that definition either -- it just needs to be defined before you compile the code, obviously, if you are actually going to call A::method1() somewhere submitting an instance of a D object.

ps. I was wrong to say you could do this with void pointers -- only in C, not C++.

Why not just split the definition/implementation and forward-declare A? Problem solved.