Best Way To Approach This?

Hi,

Now in my project i need a main GUI Manager class, also loads of individual gui_functionaility classes (such as custom file Dialog gui).

Now the GUI manager distributes these gui_functionaility classes allowing other classes to inherit this functionaility through the gui manager.

How would I go about this, classes that have classes in it protected section...Can you even do that?

Cheers
Alex

You would use inheritance. I don't think you need to use composition unless you have some has-a relationships. Is that what you were asking?

Quote:

---

Originally Posted by appleGuy

How would I go about this, classes that have classes in it protected section...Can you even do that?

---

Sure you can. It's called class nesting. One common usage is to create functors that allow a more specialized usage of the STL algorithms:

Code:

---

/*
A simple class with a string data member and a function that returns its member.
*/

class CItem {
public:
    CItem() {};
    virtual ~CItem() {};

    std::string id() const { return id_; }

private:
    std::string    id_;
};

/*
CInventory is an array of CItems. In its private section a functor is created
to help delete an element by the id data member of CItem.
*/

class CInventory {
public:
    CInventory();
    virtual ~CInventory() {};

    virtual CInventory& remove(const std::string&);

protected:
    std::vector<CItem*> contents_;

private:
    class is_ID {
        public:
            is_ID(const std::string& s): id_(s) {}
            bool operator()(const CItem* obj) const { return obj->id() == id_; }
        private:
            std::string id_;
    };

};

/*
This is the definition of CInventory::remove(). In it, the algorithm find_if() is
used with a predicate function. Our functor defined as a private member.
This way it was possible to find elements based on CItem data members.
/*

CInventory& CInventory::remove(const std::string& str) {

    std::vector<CItem_Ptr>::iterator iter;
    iter = std::find_if(contents_.begin(), contents_.end(), is_ID(str) );

    if( iter == contents_.end() ) {
        std::cerr << '\n' << "Object is not in inventory." << std::endl;
        return *this;
    }

    // Ok to remove
    contents_.erase(iter);

    return *this;

}

---

I don't see any class nesting there.

Class "is_ID" is declared in class "CInventory". Would that not be a nested class example?

Aha.

Quote:

---

private:
class is_ID {
public:
is_ID(const std::string& s): id_(s) {}
bool operator()(const CItem* obj) const { return obj->id() == id_; }
private:
std::string id_;
};

};

---

The lack of caps on the nested class threw me. Honestly didn't see it first time around.
Hideous if you ask me.

Other than the fact I stripped most of the code from those classes to simplify them for that example, and the fact I changed back to regular pointers instead of the smart pointers I have in place (also to simplify the example), I don't see a problem with using functors as private members of a class. As long as they make sense, of course.

Do you have a better option? I would honestly like to know. I have these in place in my code on a few classes.

cool,

Sounds like a good idea (class nesting).
So if say 3 classes were nested in a class called say guiManager. Would everyting that directly inherits from guiManager be able to use the functionaility from the nested classes?

Also are nested classes quite common and are there any disadvantages of using them?

Edit: Also can you declare a class in a class and define it seperatly?

Cheers
Alex

Hard to define common in this case, I guess. Nested classes are seen in code, yes.

Nested classes are used when the relationship between the surrounding class and the nested class is very close. Usually when the nested class is meant to help the implementation of the surrounding class.

If the nested classes are defined (or declared) in the public or protected parts of the surrounding class, then derived members will have access to it. But again, the objective of a nested class is to provide help in the implementation of its surrounding class, so I guess public access nested classes are much less common.

oK,

Maybe the way im going about this is not the right way.

To put it into perspective, how would an standard application do its GUI.
Would It have a GUI_Manager Class that has many nested classes such as File Dialog, or would there just be a defined library of gui classes that get called upon when needed..

Its really hard to explain..so bear with me

Cheers
Alex

You would not want to nest classes such as FileDialog under a GUI Manager class. The number of classes necessary would be large, and there is no reason to nest them. Nesting is for helper classes specific to the parent class.

I guess we are having a little hard time providing you a real answer to your question because you didn't define to us yet what do you mean by a GUI_Manager class. What do you plan to have this class do?

Regardless, as Daved said, forget about nested classes for now. I already regreat having given you an example :)

Quote:

---

Originally Posted by Mario F.

I guess we are having a little hard time providing you a real answer to your question because you didn't define to us yet what do you mean by a GUI_Manager class. What do you plan to have this class do?

Regardless, as Daved said, forget about nested classes for now. I already regreat having given you an example :)

---

well the gui_manager class will will be called upon for specific gui functionaility, say if the program wants a file dialog, the gui_manager will distribute accordingly (by calling the relevent class).

However im now thinking that this is pointless and less efficent..

-Alex