PV913PersonClassFixedFileIO

#include <iostream>
#include <fstream>

class Person
{
    char* fname;
    char* sname;
    uint32_t id;
    static const uint8_t fileNameSize{ 25 };
public:
    Person(const char* fnameP, const char* snameP, const uint32_t idP);
    Person() : fname{ nullptr }, sname{ nullptr }, id{ 0 }{};
    Person(uint32_t idP) : Person(nullptr, nullptr, idP) { load(); };
    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);
    bool save();
    bool load();
};

Person::Person(const char* fnameP, const char* snameP, const uint32_t idP)
    :fname{ fnameP ? new char[strlen(fnameP) + 1] : nullptr }, sname{ snameP ? new char[strlen(snameP) + 1] : nullptr}, id{ idP }
{
    if (fname)
    {
        strcpy_s(fname, strlen(fnameP) + 1, fnameP);
    }
    if (sname)
    {
        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 Person::save()
{
    char fileName[Person::fileNameSize]{"_person"};
    char idStr[10];
    _itoa_s(id, idStr, 10);
    strncat_s(fileName, idStr, Person::fileNameSize);

    std::ofstream out;
    out.open(fileName);

    if (!out)
    {
        std::cout << "IOERROR! Filename: " << fileName << '\n';
        return false;
    }

    out << id << '\n';
    out << fname << '\n';
    out << sname << '\n';
    out.close();

    //std::cout << "Filename: " << fileName << '\n';
    return true;
}

bool Person::load()
{
    char fileName[Person::fileNameSize]{ "_person" };
    char idStr[10];
    _itoa_s(id, idStr, 10);
    strncat_s(fileName, idStr, Person::fileNameSize);

    char buf[255];

    std::ifstream in;
    in.open(fileName);

    if (!in)
    {
        std::cout << "IOERROR! Filename: " << fileName << '\n';
        return false;
    }

    in >> id;
    in.ignore();
    in.getline(buf, 255);
    setFname(buf);
    in.getline(buf, 255);
    setSname(buf);
    in.close();

    //std::cout << "Filename: " << fileName << '\n';
    return true;
    return true;
}

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];
        personsDyn[i].save();
    }

    std::cout << '\n';
    std::cout << "Restored from files:\n";

    Person* personsFile = new Person[3]{1,2,3};
    for (int i{ 0 }; i < 3; ++i)
    {
 /*       std::cout << personsFile[i] << '\n';
        personsFile[i].setId(i + 1);
        personsFile[i].load();*/
        std::cout << personsFile[i] << '\n';
    }

    delete[] personsFile;

    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;
}

int main()
{
    testPerson();
}