Coursework update

#include <iostream>
#include <string>
#include <sstream>
#include <vector>

using namespace std;

class Person
{
protected:
        string forename, surname, email;

public:
        Person(){}
        Person(string s, string f):surname(s), forename(f){}
        string get_surname() const//get the persons surname
        {
                return surname;
        }

        string get_forename() const//get the persons first name
        {
                return forename;
        }

        virtual bool has_telephone() const{ return false; } //returns true if person has a telephone number

        virtual bool has_email() const { return false; }//returns true if the person has a email

        virtual string get_email() const { return ""; };//gets the persons email
        virtual string get_telephone() const { return ""; };//gets the persons telephone number

        friend bool operator==(Person &person1, Person &person2);

        virtual void type() const //persons class type for later functions
        {
                cout << "person" << endl;
        };
};
//----------------------------------------------------------------------------------------------------
//Override the == comparator to compare person objects
//bool operator== (Person &person1, Person &person2)
//{
//      cout << person1.get_surname() << " " << person2.get_surname();
//      return ((person1.forename == person2.forename) && (person1.surname == person1.surname));
//}

//person with telephone class with class person inheritance
class Person_with_telephone : public virtual Person
{
protected:
        string telephone_number;

public:
        Person_with_telephone(){}
        Person_with_telephone(string s, string f, string t) : Person(s, f), telephone_number(t){}

        bool has_telephone() const {
        return !telephone_number.empty();
        }

        virtual string get_telephone() const//get persons telephone number
        {
                return telephone_number;
        }

        void set_telephone(string &t)//set classes telephone number
        {
                telephone_number = t;
        }

        virtual void type() const //class type shown as t for telephone
        {
                cout << "person w/ t" << endl;
        };
};
//----------------------------------------------------------------------------------------------------
class Person_with_email : public virtual Person
{
protected:
        string email;

public:
        Person_with_email(){}
        Person_with_email(string s, string f, string e) :Person(s, f), email(e){}

        bool has_email() const
        {
                return !email.empty();
        }

        virtual string get_email() const
        {
                return email;
        }

        void set_email(string &e)
        {
                email = e;
        }

        virtual void type() const
        {
                cout << "person w/ e" << endl;
        };
};
//----------------------------------------------------------------------------------------------------
class Person_with_telephone_email : public Person_with_telephone, public Person_with_email{
public:
        Person_with_telephone_email(){}
        Person_with_telephone_email(string s, string f, string t, string e) : Person(s, f), Person_with_telephone(s, f, t), Person_with_email(s, f, e) {}

        virtual void type() const
        {
                cout << "person w/ t + e" << endl;
        };

};
//----------------------------------------------------------------------------------------------------
ostream& operator<<(ostream &os, Person &p)
{
        if (p.has_email() && p.has_telephone())
    {
                cout << "<person" << " S " << p.get_surname() << " F " << p.get_forename() << " E " << p.get_email() << " T " << p.get_telephone() << " >";
        }
        else if (p.has_email())
        {
                cout << "<person" << " S " << p.get_surname() << " F " << p.get_forename() << " E " << p.get_email() << " >";
        }
        else if (p.has_telephone())
        {
                cout << "<person" << " S " << p.get_surname() << " F " << p.get_forename() << " T " << p.get_telephone() << " >";
        }
        else
        {
                cout << "<person" << " S " << p.get_surname() << " F " << p.get_forename() << " >";
        }
        return os;
}
//----------------------------------------------------------------------------------------------------
istream& operator>>(istream &is, Person &p){
        string opening, s, surname, f, forename, closing;
        if (
                (is >> opening >> s >> surname >> f >> forename >> closing)
                &&
                ((opening == "<person") && (s == "S") && (f == "F") && (closing == ">"))
                )
        {
                p = Person(surname, forename);
        }
        return is;
}

istream& operator>>(istream &is, Person_with_email &p){
        string opening, s, surname, f, forename, e, email, closing;
        if (
                (is >> opening >> s >> surname >> f >> forename >> e >> email >> closing)
        &&
                ((opening == "<person") && (s == "S") && (f == "F") && (e == "E") && (closing == ">"))){
                p = Person_with_email(surname, forename, email);
        }
        return is;
}

istream& operator>>(istream &is, Person_with_telephone &p){
        string opening, s, surname, f, forename, t, telephone, closing;
        if (
                (is >> opening >> s >> surname >> f >> forename >> t >> telephone >> closing) &&
                ((opening == "<person") &&
                (s == "S") &&
                (f == "F") &&
                (t == "T") &&
                (closing == ">"))
                )
        {
                p = Person_with_telephone(surname, forename, telephone);
        }
        return is;
}

istream& operator>>(istream &is, Person_with_telephone_email &p){
        string opening, s, surname, f, forename, t, telephone, e, email, closing;
        if (
                (is >> opening >> s >> surname >> f >> forename >> t >> telephone >> e >> email >> closing) &&
                ((opening == "<person") &&
                (s == "S") &&
                (f == "F") &&
                (t == "T") &&
                (e == "E") &&
                (closing == ">"))
                )
        {
                p = Person_with_telephone_email(surname, forename, telephone, email);
        }
        return is;
}

Person* make_person(istream &stream){
        Person *person_pointer = new Person;
        stream >> *person_pointer;
        return person_pointer;
}

Person_with_email* make_person_email(istream &stream){
        Person_with_email *person_pointer = new Person_with_email;
        stream >> *person_pointer;
        return person_pointer;
}

Person_with_telephone* make_person_telephone(istream &stream){
        Person_with_telephone *person_pointer = new Person_with_telephone;
        stream >> *person_pointer;
        return person_pointer;
}

Person_with_telephone_email* make_person_telephone_email(istream &stream){
        Person_with_telephone_email *person_pointer = new Person_with_telephone_email;
        stream >> *person_pointer;
        return person_pointer;
}

istream & read_person(istream &in, Person * & p){
        string input;
        getline(in, input);
        stringstream stream(input);
        string e = " E ";
        string t = " T ";
        bool has_e = false;
        bool has_t = false;

        if (input.find(e) != std::string::npos){ has_e = true; }
        if (input.find(t) != string::npos){ has_t = true; }

        if (has_e && has_t) {
                cout << "e + t\n";
                Person_with_telephone_email *person_pointer = make_person_telephone_email(stream);
                p = person_pointer;
        }
        else if (has_e){
                cout << "e\n";
                Person_with_email *person_pointer = make_person_email(stream);
                p = person_pointer;
        }
        else if (has_t){
                cout << "t \n";
                Person_with_telephone *person_pointer = make_person_telephone(stream);
                p = person_pointer;
        }
        else{
                cout << "is person \n";
                Person *person_pointer = make_person(stream);
                p = person_pointer;
        }
        return in;
}
//----------------------------------------------------------------------------------------------------
/**
        Container class for storing and handling objects of class Person
*/
template <typename Contact>
class Contacts {

private:
        vector<Person*> data;
        int data_size;

public:
        Contacts() {
                data_size = 0;
        }

        void add(Person p ) {
                data.push_back(&p);
                data_size++;
        }

        void remove(int i) {
                data.erase(data.begin() + (i - 1));
                data_size--;
        }



        Contact get(int i) {
                return data[i];
        }

        int get_size() {
                return data.size();
        }

        ~Contacts() {

                data.clear();
        }
};
//----------------------------------------------------------------------------------------------------
//this is main
int main(){
//Tests the == compare
//      Person *p = new Person("Dave", "Harry");
//      Person *s = new Person("Dave", "Harry");
//      Person *d = new Person("Dave", "Johns");
        // if (p == s)
        // {
        //      cout << "They're the same!\n";
        // }+
//Tests the read_person istream
//    Person *p = 0;
//      string ss = "<person S Smith N Tom >\n<person S Smith N Dick T +49.921.1434 >\n<person S Smith N Harry E hsmith@gmail.com >\n<person S Smith N Mary T +39.921.1434 E msmith@gmail.com >\n<person S John N John T + 33.921.1434 E jjohn@gmail.com >";
//      stringstream iss(ss);
//      while (read_person(iss, p) && p)
//              cout << *p << endl;

//Tests the output and input of the vector
    Contacts <Person> c;

    cout << c.get_size() << endl;
        Person john1("John","Smith");
        c.add(john1);
        Person_with_telephone john2("John", "Tim","+02958.5645764.75");
        c.add(john2);
        Person_with_email john3("John", "Jones","email@email.com");
        c.add(john3);
        Person_with_telephone_email john4 ("John", "Adams", "+33.02.0101.0202", "email@email.com");
        c.add(john4);

        //c.get causing errors
        cout << c.get(1) << endl << c.get(2) << endl << c.get(3) << endl;
        cout << c.get_size() << endl;
}