#include <iostream>
#include <string.h>

static char *xstrdup(const char *str) {
  char *duplicate = new char [strlen(str) + 1];
  strcpy(duplicate, str);
  return duplicate;
}


class Person {
 public:
  Person(const char *name,
         const char *egn,
         const char *address);
  ~Person();

  // Getters.
  const char *name() const;
  const char *egn() const;
  const char *address() const;

  virtual void printInStream(std::ostream &) const;
 private:
  const char *name_;
  const char *egn_;
  const char *address_;

  // Disable copying.
  Person(const Person &p);
  void operator = (const Person &p);
};

Person::Person(const char *name,
               const char *egn,
               const char *address) {
  name_ = xstrdup(name);
  egn_ = xstrdup(egn);
  address_ = xstrdup(address);
}

Person::~Person() {
  delete [] name_;
  delete [] egn_;
  delete [] address_;
}

const char *Person::name() const { return name_; }
const char *Person::egn() const { return egn_; }
const char *Person::address() const { return address_; }

void Person::printInStream(std::ostream &out) const {
  out << "Person "
      << "name: "    << name() << " "
      << "egn: "     << egn()  << " "
      << "address: " << address();
}

// This will work on all subclasses due to polymorphism.
std::ostream &operator << (std::ostream &out, const Person &p) {
  p.printInStream(out);
  return out;
}

class EstateOwner : public Person {
 public:
  EstateOwner(const char *name,
              const char *egn,
              const char *address,
              const char *owned[],
              bool own_key);  // NULL terminated
  ~EstateOwner();

  // Getters.
  int ownedCount() const;
  const char *ownAddressAt(int index) const;
  bool ownKey() const;

  virtual void printInStream(std::ostream &) const;
 private:
  int owned_count_;
  const char **owned_address_;
  bool own_key_;

  // Disable copying.
  EstateOwner(const EstateOwner &e);
  void operator = (const EstateOwner &e);
};

EstateOwner::EstateOwner(const char *name,
                         const char *egn,
                         const char *address,
                         const char *owned[],
                         bool own_key)
    : Person(name, egn, address) {
  for (int i = 0;; ++i)
    if (owned[i] == NULL) {
      owned_count_ = i;
      break;
    }
  owned_address_ = const_cast<const char **>(new char * [owned_count_]);
  for (int i = 0; i < owned_count_; ++i)
    owned_address_[i] = strdup(owned[i]);
  own_key_ = own_key;
}

EstateOwner::~EstateOwner() {
  for (int i = 0; i < owned_count_; ++i)
    delete [] owned_address_[i];
  delete [] owned_address_;
}

int EstateOwner::ownedCount() const { return owned_count_; }
const char *EstateOwner::ownAddressAt(int index) const {
  return owned_address_[index];
}
bool EstateOwner::ownKey() const { return own_key_; }

void EstateOwner::printInStream(std::ostream &out) const {
  Person::printInStream(out);
  out << " owning: ";
  for (int i = 0; i < ownedCount(); ++i) {
    out << "\"" << ownAddressAt(i) << "\"";
    if (i != ownedCount() - 1)
      out << ", ";
  }
  out << " key: " << (ownKey() ? "yes" : "no");
}

// NULL terminated.
void PrintInfo(Person *persons[]) {
  for (int i = 0; persons[i]; ++i) {
    bool found = false;
    for (int j = 0; persons[j]; ++j) {
      EstateOwner *eo = dynamic_cast<EstateOwner *>(persons[j]);
      if (eo == NULL) continue;
      for (int k = 0; k < eo->ownedCount(); ++k) {
        if (strcmp(eo->ownAddressAt(k), persons[i]->address()) == 0) {
          found = true;
          goto end_of_j;
        }
      }
end_of_j:;
    }
    if (found) {
      std::cout << *(persons[i]) << std::endl;
    }
  }

}

int main() {
  const char *owned[] = { "sofiq bg", NULL };
  Person *persons[] = {
    new Person("Pe6o", "2222222222", "sofiq bg"),
    new Person("Q6o",  "1111111111", "uk"),
    new EstateOwner("Go6o", "3333333333", "usa", owned, false),
    NULL,
  };
  PrintInfo(persons);
  for (int i = 0; persons[i]; ++i)
    delete persons[i];

  return 0;
}