PersonFlatPartly

#include <iostream>

class Person
{
    char* fname;
    char* sname;
    uint32_t id;
public:
    Person(const char* fnameP, const char* snameP, const uint32_t idP);
    Person() : fname{ nullptr }, sname{ nullptr }, id{ 0 }{};
    Person(const Person& personP);
    Person(Person&& personP);
    Person& operator=(const Person& personP);
    Person& operator=(Person&& personP);
    ~Person() { delete[] fname; delete[] sname; };
    const char* getFname() const { return fname; };
    const char* getSname() const { return sname; };
    const uint32_t getId() const { return id; };
    Person& setFname(const char* fnameP);
    Person& setSname(const char* snameP);
    Person& setId(const uint32_t idP) { id = idP; return *this; };
    friend std::ostream& operator<<(std::ostream& out, const Person& personP);
    friend std::istream& operator>>(std::istream& out, Person& personP);
    friend bool operator==(const Person& lhs, const Person& rhs);
    friend bool operator!=(const Person& lhs, const Person& rhs);
};

Person::Person(const char* fnameP, const char* snameP, const uint32_t idP)
    :fname{new char[strlen(fnameP)+1]}, sname{ new char[strlen(snameP) + 1] }, id{idP}
{
    strcpy_s(fname, strlen(fnameP) + 1, fnameP);
    strcpy_s(sname, strlen(snameP) + 1, snameP);
}

Person::Person(const Person& personP)
    :fname{ new char[strlen(personP.fname) + 1] }, sname{ new char[strlen(personP.sname) + 1] }, id{ personP.id }
{
    strcpy_s(fname, strlen(personP.fname) + 1, personP.fname);
    strcpy_s(sname, strlen(personP.sname) + 1, personP.sname);
}

Person::Person(Person&& personP)
    :fname{ personP.fname}, sname{personP.sname}, id{ personP.id }
{
    personP.fname = nullptr;
    personP.sname = nullptr;
    personP.id = 0;
}

Person& Person::operator=(const Person& personP)
{
    if (this == &personP) { return *this; }

    delete[] fname;
    delete[] sname;

    fname = new char[strlen(personP.fname) + 1];
    sname = new char[strlen(personP.sname) + 1];
    id =  personP.id;

    strcpy_s(fname, strlen(personP.fname) + 1, personP.fname);
    strcpy_s(sname, strlen(personP.sname) + 1, personP.sname);

    return *this;
}

Person& Person::operator=(Person&& personP)
{
    if (this == &personP) { return *this; }

    delete[] fname;
    delete[] sname;

    fname = personP.fname;
    sname = personP.sname;
    id = personP.id;

    personP.fname = nullptr;
    personP.sname = nullptr;
    personP.id = 0;

    return *this;
}

Person& Person::setFname(const char* fnameP)
{
    delete[] fname;
    fname = new char[strlen(fnameP) + 1];
    strcpy_s(fname, strlen(fnameP) + 1, fnameP);
    return *this;
};

Person& Person::setSname(const char* snameP)
{
    delete[] sname;
    sname = new char[strlen(snameP) + 1];
    strcpy_s(sname, strlen(snameP) + 1, snameP);
    return *this;
};

std::ostream& operator<<(std::ostream& out, const Person& personP)
{
    if (personP.fname and personP.sname and personP.id)
    {
        out << "[" << personP.id << ' ' << personP.fname << ' ' << personP.sname << "]";
    }
    else
    {
        out << "[empty person]";
    }

    return out;
}

std::istream& operator>>(std::istream& in, Person& personP)
{
    in >> personP.id >> personP.fname >> personP.sname;
    return in;
}

bool operator==(const Person& lhs, const Person& rhs)
{
    return (lhs.id == rhs.id and strcmp(lhs.fname,rhs.fname) == 0 and strcmp(lhs.sname, rhs.sname) == 0);
}

bool operator!=(const Person& lhs, const Person& rhs)
{
    return !(lhs == rhs);
}

bool testPerson()
{
    const Person person1{ "Ivan", "Ivanov", 1 };
    Person person2{ "Sidor", "Sidorov", 2 };

    std::cout << person1 << '\n';
    std::cout << person2 << '\n';

    Person person3{ person1 };
    Person person4{ std::move(person2) };

    std::cout << person3 << '\n';
    std::cout << person4 << '\n';

    std::cout << person1 << '\n';
    std::cout << person2 << '\n';

    Person person5{};
    person5.setFname("Petr").setSname("Petrov").setId(3);

    Person person6{};
    person6 = person5;

    std::cout << person5 << '\n';
    std::cout << person6<< '\n';

    Person person7{};
    person7 = std::move(person6);

    std::cout << person6 << '\n';
    std::cout << person7 << '\n';

    Person persons[3]{ {"Ivan", "Ivanov", 1},{"Sidor","Sidorov",2},{"Petr","Petrov",3} };

    for (int i{ 0 }; i < 3; ++i)
    {
        std::cout << persons[i];
    }
    std::cout << '\n';

    Person* personsDyn = new Person[3];
    personsDyn[0].setFname("Ivan").setSname("Ivanov").setId(1);
    personsDyn[1].setFname("Sidor").setSname("Sidorov").setId(2);
    personsDyn[2].setFname("Petr").setSname("Petrov").setId(3);

    for (int i{ 0 }; i < 3; ++i)
    {
        std::cout << personsDyn[i];
    }

    std::cout << '\n';

    for (int i{ 0 }; i < 3; ++i)
    {
        personsDyn[i] = std::move(persons[i]);
        std::cout << persons[i];
        std::cout << personsDyn[i];
    }

    delete[] personsDyn;

    std::cout << '\n';

    std::cout << (Person{ "Ivan", "Ivanov", 1 } == Person{ "Ivan", "Ivanov", 1 }) << '\n';
    std::cout << (Person{ "Ivan", "Ivanov", 1 } == Person{ "Ivn", "Ivaov", 2 }) << '\n';
    std::cout << (Person{ "Ivan", "Ivanov", 1 } != Person{ "Ivan", "Ivanov", 1 }) << '\n';
    std::cout << (Person{ "Ivan", "Ivanov", 1 } != Person{ "Ivn", "Ivaov", 2 }) << '\n';

    return true;
}

class Flat
{
    uint32_t number;
    uint16_t roomsCount;
    Person* occupants;
    uint16_t occupantsCount;
    void _addOccupantPlace();
    void _removeOccupantAt(const uint16_t idx);
public:
    Flat(const uint32_t numberP, const uint16_t roomsCountP)
        : number{ numberP }, roomsCount{ roomsCountP }, occupants{ nullptr }, occupantsCount{ 0 } {};
    Flat() : Flat(0, 0) {};
    const uint32_t getNumber() const { return number; };
    const uint16_t getRoomsCount() const { return roomsCount; };
    Flat& setNumber(const uint32_t numberP) { number = numberP; return *this; };
    Flat& setRoomsCount(const uint16_t roomsCountP) { roomsCount = roomsCountP; return *this; };
    ~Flat() { delete[] occupants; }
    Flat& addOccupant(const Person& personP);
    Flat& addOccupant(Person&& personP);
    bool removeOccupant(const Person& personP);
    bool removeOccupantById(const uint16_t id);
    friend std::ostream& operator<<(std::ostream& out, const Flat& flatP);
    //friend std::istream& operator>>(std::istream& out, Flat& flatP);
};

void Flat::_addOccupantPlace()
{
    Person* newOccupants{ new Person[occupantsCount + 1] };
    for (uint16_t i{ 0 }; i < occupantsCount; ++i)
    {
        newOccupants[i] = std::move(occupants[i]);
    }
    delete[] occupants;
    occupants = newOccupants;
    ++occupantsCount;
}

void Flat::_removeOccupantAt(const uint16_t idx)
{
    Person* newOccupants{ new Person[occupantsCount - 1] };
    for (uint16_t i{ 0 }; i < occupantsCount - 1; ++i)
    {
        i < idx ? newOccupants[i] = std::move(occupants[i]) : newOccupants[i] = std::move(occupants[i+1]);
    }
    delete[] occupants;
    occupants = newOccupants;
    --occupantsCount;
}

Flat& Flat::addOccupant(const Person& personP)
{
    _addOccupantPlace();
    occupants[occupantsCount - 1] = personP;
    return *this;
}

Flat& Flat::addOccupant(Person&& personP)
{
    _addOccupantPlace();
    occupants[occupantsCount - 1] = std::move(personP);
    return *this;
}

bool Flat::removeOccupant(const Person& personP)
{
    for (uint16_t i{ 0 }; i < occupantsCount; ++i)
    {
        if (occupants[i] == personP)
        {
            _removeOccupantAt(i);
            return true;
        }
    }
    return false;
}

bool Flat::removeOccupantById(const uint16_t id)
{
    for (uint16_t i{ 0 }; i < occupantsCount; ++i)
    {
        if (occupants[i].getId() == id)
        {
            _removeOccupantAt(i);
            return true;
        }
    }
    return false;
}

std::ostream& operator<<(std::ostream& out, const Flat& flatP)
{
    if (flatP.number and flatP.roomsCount)
    {
        out << "[ #" << flatP.number << ' ' << flatP.roomsCount << " rooms ";
        if (flatP.occupantsCount)
        {
            for (uint16_t i{ 0 }; i < flatP.occupantsCount; ++i)
            {
                out << flatP.occupants[i];
            }
        }
        else
        {
            out << "[no occupants]";
        }
        out << "]";
    }
    else
    {
        out << "[empty flat]";
    }
    return out;
}
bool testFlat()
{
    Flat flat1{};
    std::cout << flat1 << '\n';

    Flat flat2{1,3};
    std::cout << flat2 << '\n';

    flat2.addOccupant(Person{ "Ivan","Ivanov", 1}).addOccupant(Person{ "Sidor","Sidorov", 2});
    std::cout << flat2 << '\n';

    Person person1{ "Petr", "Petrov",3 };
    flat2.addOccupant(person1);

    Person person2{ "Ivan", "Durak",4 };
    flat2.addOccupant(std::move(person2));

    std::cout << flat2 << '\n';
    std::cout << person1 << '\n';
    std::cout << person2 << '\n';

    flat2.removeOccupant(Person{ "Ivan", "Durak",4 });
    std::cout << flat2 << '\n';
    flat2.removeOccupantById(1);
    std::cout << flat2 << '\n';
    return true;
}

int main()
{
    testPerson();
    testFlat();
}