Inherent a constant feature from a parent

grob115 · 07-19-2012, 10:39 AM

Hi, if I want to write a C++ program with which I want to store all the common details for a family in the parent level once for all childs, rather than one copy for each child.

Normally if a child is instantiated it creates its parent, and all the variables that is to be held by the parent. If all childs belong to the same parent, then wouldn't it make sense to do the common parent variables once only?

The only way I can think of is to have all the childs hold the a pointer to the same parent, rather than using inheritance.

Can someone please suggest if there is a better way to do this?

Code:

class Parent {
  protected:
    std::string familyName;
  public:
    Parent(std::string surname) : familyName(surname) {
    }

    std::string getFamilyName() {
      return familyName;
    }

    std::string getAddress() {
      return "88 Manhattan Ave";
    }
}

class Child {
  private:
    std::string firstName;
    Parent * parent;
  public:
    Child(std::string firstName, Parent * parent) {
      this->firstName = firstName;
      this->parent = parent;
    }
    std::string getLastName() {
      return parent->getFamilyName();
    }
    std::string getParentAddress() {
      return parent->getAddress();
    }
}

int main() {
  Parent * parent("Cunningham");
  Child child1("John", parent);
  Child child2("Amy", parent);
  child1.getLastName();
  child2.getParentAddress();
}

dwhitney67 · 07-19-2012, 11:25 AM

Your design assumes that a child has a parent (the child could be an orphan). Your design also assumes that the parent and child have the same surname and address; this is not always the case.

If you are attempting to define a family tree, then obviously the parent's are children of other parents.

Anyhow, your design is ok if you are merely attempting a loose association between two objects.

How about something like:

Code:

class Address
{
    std::string street;
    std::string city;
    std::string country;
    ...
};

class Person
{
    std::string firstName;
    std::string lastName;
    ...
};

class Parent : public Person
{
    Address addr;
    std::vector<Child*> children;
    ...
};

class Child : public Person
{
    Address addr;
    Parent* parents[2];
    ...
};

I did not put too much thought into the design above, but basically everyone has an Address and is a Person. Parents have 0 or more Child(ren), and Child(ren) has two Parents.

P.S. Perhaps Parent should be a sub-class of Child?