Dynamic Binding

I'm having some trouble figuring this out.

I have a class heirarchy

Project
--> SimpleProject
--> MinorProject
--> MajorProject

Now a simple project and a minor project can be merged to create a simple project, a simple project and a major project can be merged to create a major project. Basically any project can be merged with any other project which creates a new project.

A simple project contains one and only one task. A Minor project contains a list of tasks, so merging a simple and minor project would create a new minor project with the list of the previous minor project and with the task from the simple project added to it. Also a major project is just like a minor project but with dependency's between tasks. So merging a major and a minor gives a major. Does this all make sense?

So basically i want to write a function which does this. I have been told it can be done using Dynamic Binding but im not seeing how...

Here are my class definition files if that helps you picture this more

Project.h:

Code:

---

#ifndef PROJECT_H
#define PROJECT_H

// forward declaration
class Task;

class Project
{

public:
        Project();
        Project(const Project &);       
        virtual ~Project();

        // some pure virtual functions
        virtual void AddTask(Task *) = 0;
        virtual void DoTask() = 0;
        virtual bool HasTasks() = 0;

private:
        // still to add...
};

#endif

---

SimpleProject.h:

Code:

---

#ifndef SIMPLEPROJECT_H
#define SIMPLEPROJECT_H

#include "Project.h"
#include "Task.h"

class SimpleProject : public Project
{

public:
        SimpleProject();
        SimpleProject(const SimpleProject &);
        ~SimpleProject();
        void AddTask(Task *);
        void DoTask();
        bool HasTasks();
        SimpleProject & operator=(const SimpleProject & other);
        friend std::ostream & operator<<(std::ostream & os,
                                                                        const SimpleProject & sp);
        friend bool operator==(const SimpleProject & left,
                                                  const SimpleProject & right);
        friend bool operator!=(const SimpleProject & left,
                                                  const SimpleProject & right);

private:
        Task *task;
        // the total number of tasks
        int numTasks;
};

#endif

---

MinorProject.h

Code:

---

#ifndef MINORPROJECT_H
#define MINORPROJECT_H

#include <list>
#include "Project.h"
#include "Task.h"

class MinorProject : public Project
{

public:
        MinorProject();
        MinorProject(const MinorProject &);       
        ~MinorProject();
        void AddTask(Task *);
        void DoTask();
        bool HasTasks();
        MinorProject & operator=(const MinorProject &);
        friend std::ostream & operator<<(std::ostream &, const MinorProject &);
        friend bool operator==(const MinorProject &, const MinorProject &);
        friend bool operator!=(const MinorProject &, const MinorProject &);

private:
        list<Task> *task_list;
};

#endif

---

MajorProject.h (this one is not yet competed...):

Code:

---

#ifndef MAJORPROJECT_H
#define MAJORPROJECT_H

#include "Project.h"
#include "Task.h"
#include <list>
#include <vector>

class MajorProject : public Project
{

public:
        MajorProject();
        MajorProject(const MajorProject &);
        //MajorProject(list<Task> *, vector<int *> *);
        ~MajorProject();
        void AddTask(Task *);
        void AddDependency(const vector<int> &);
        void DoTask();
        bool HasTasks();
        MajorProject & operator=(const MajorProject & other);
        friend std::ostream & operator<<(std::ostream & os, const MajorProject & mp);
        friend bool operator==(const MajorProject & left, const MajorProject & right);
        friend bool operator!=(const MajorProject & left, const MajorProject & right);

private:
        list<Task> *task_list;
        vector<vector<int>> *depend_vec;
};

#endif

---

If anyone can point me int he rigth direction i would appreciate that.

Quote:

---

Originally Posted by gpr1me

A simple project contains one and only one task. A Minor project contains a list of tasks, so merging a simple and minor project would create a new minor project with the list of the previous minor project and with the task from the simple project added to it. Also a major project is just like a minor project but with dependency's between tasks. So merging a major and a minor gives a major. Does this all make sense?

So basically i want to write a function which does this. I have been told it can be done using Dynamic Binding but im not seeing how...

---

As far as I understand your problem (Correct me if I'm wrong), A Major project has a "collection" of minor projects.. and a Minor project has a "collection" of simple projects.

Representing the "has-a" relationship is best done with a class member rather than dynamic binding IMHO.

eg,

Code:

---

class SimpleProject
{
  Task t;
};

class MinorProject
{
  std::list<SimpleProject> lsSimple;
};

class MajorProject
{
  std::list<MinorProject> lsMinor;
};

---

Of course, Dynamic binding may come in useful for other aspects of the program, so I wouldn't rule it out completely (There may be some common accessor methods which are true to all types of projects) - but I don't believe inheritance represents the relationship you're looking for.