Создать классы Дом, Квартира и Человек

#pragma once
#include "Occupant.h"
#include "House.h"
class Flat
{
    int size;     // кол-во жильцов в одной квартире
    Occupant* flats; // массив объектов класса Occupant жильцы
public:
 
    Flat();
    int GetSize() { return this->size; }  //геттер
    void SetSize(int);                     // сеттер
 
    void AddOccupant();         //Создает временного пользователя, и выводит форму для ввода данных(View) 
    void SaveOccupant(Occupant a); // добавляет пользователя в массив
 
    ~Flat();
};

#include "Flat.h"
#include "Occupant.h"
#include "Stdafx.h"
 
 
Flat::Flat()
{
    this->size = 0;
}
 
void Flat::SaveOccupant(Occupant a)
{
    if (this->size == 0) {
        this->flats = new Occupant[1];
    }
    else 
    {
        Occupant* buffer;
        buffer = new Occupant[this->size];
        for (int i = 0; i < this->size; i++) {
            buffer[i] = this->flats[i];
        }
        this->flats = new Occupant[this->size + 1];
        for (int i = 0; i < this->size; i++) {
            this->flats[i] = buffer[i];
        }
    }
 
    this->flats[this->size] = a; // - красивая запись
 
    this->size++;
 
}
 
void Flat::SetSize(int size)
{
    this->size = size;
}
 
void Flat::AddOccupant()
{
    Occupant tmp;
    tmp.Input();
    this->SaveOccupant(tmp);
 
}
 
 
Flat::~Flat()
{
    delete[] flats;
}

#pragma once
#include <iostream>
using namespace std;
class Occupant
{
    char *name;
    char* surname;
    char* phone;
    
public:
 
    
    Occupant();
    Occupant(Occupant&in);
    /*Occupant(char*name,char*surname,char*phone);*/
 
    // сеттеры
    void setName(char *str);
    void setSurname(char *str);
    void setPhone(char *str);
    
    // геттеры
    char* getName() { return this->name; }
    char* getSurname() { return this->surname; }
    char* getPhone() { return this->phone; }
    
 
    // Конструктор копирования
    Occupant(const Occupant&other);
 
    // очищение памяти
    void clear(char * str);
 
    //ввод данных
    void Input();
 
    // вывод данных
    void Print();
    
 
    
    ~Occupant();
};

#include "Occupant.h"
#include "Stdafx.h"
#include "House.h"
 //конструктор по умолчанию
Occupant::Occupant()
{
}
 
//конструктор с параметрами
//Occupant::Occupant(char*name, char*surname, char*phone)
//{ 
//  this->name = name;
//  this->surname = surname;
//  this->phone = phone;
//
//}
 
Occupant::Occupant(Occupant&in)  //объект класса
{
    
    this->setName(in.getName());
    this->setSurname(in.getSurname());
    this->setPhone(in.getPhone());
}
 
 
// сеттеры
void Occupant::setName(char * str)
{
    clear(this->name);
    this->name = new char[strlen(str) + 1];
    strcpy_s(this->name, strlen(str) + 1, str);
}
 
void Occupant::setSurname(char * str) 
{
    clear(this->surname);
    this->surname = new char[strlen(str) + 1];
    strcpy_s(this->surname, strlen(str) + 1, str);
}
 
void Occupant::setPhone(char * str)
{
    clear(this->phone);
    this->phone = new char[strlen(str) + 1];
    strcpy_s(this->phone, strlen(str) + 1, str);
}
 
 
 //конструктор копирования
Occupant::Occupant(const Occupant & other)
{
    this->name = other.name;
    this->surname = other.surname;
    this->phone = other.phone;
 
    this->name = new char[strlen(other.name) + 1];
    strcpy_s(this->name, strlen(other.name) + 1, other.name);
 
    this->surname = new char[strlen(other.surname) + 1];
    strcpy_s(this->surname, strlen(other.surname) + 1, other.surname);
 
    this->phone = new char[strlen(other.phone) + 1];
    strcpy_s(this->phone, strlen(other.phone) + 1, other.phone);
 
}
 
 
void Occupant::clear(char * str)
{
    if (str != nullptr) {
        delete str;
    }
}
 
// ввод
void Occupant::Input()
{
    char tmp[1024];
    cout << "\n------------------------------------------------";
    cout << "\n Введите данные жильца" << endl;
 
    cout << "Имя : "; gets_s(tmp, 1024);
    this->setName(tmp);
 
    cout << " Фамилия :"; gets_s(tmp, 1024);
    this->setSurname(tmp);
 
    cout << " Номер телефона:"; gets_s(tmp, 1024);
    this->setPhone(tmp);
 
}
 
    // вывод
void Occupant::Print()
{
    cout << "\nДанные жильца :  "<<endl;
    cout << "Фамилия  " << this->getSurname() << endl;
    cout << "Имя " << this->getName() << endl;
    cout << "Номер телефона " << this->getPhone() << endl;
    
}
 
 
 
 
// деструктор
Occupant::~Occupant()
{
    delete[] name;
    delete[] surname;
    delete[] phone;
 
    cout << "Class occupant bye bye" << endl;
}

#include <iostream>
#include <stdlib.h>
#include <string.h>
 
class Occupant {
  // Добавим приставку m_ к именам полей,
  // так будем отличать своих от чужих ;)
  // Более подробно в:
  //  - http://habrahabr.ru/post/172091/
  char *m_name;
  char *m_surname;
  char *m_phone;
 
public:
  // Простой конструктор можно реализовать сразу при объявлении.
  //
  // Такой "странный" синтаксис означает:
  //   - до выполнения кода конструктора сделать:
  //     - m_name    равным nullptr
  //     - m_surname равным nullptr
  //     - m_phone   равным nullptr
  //
  // Замечание: nullptr пришёл к нам в С++11.
  //            Если его нет, то можно заменить его на NULL или 0.
  //            Но лучше включить поддержку C++11.
  //            https://www.cyberforum.ru/cpp-beginners/thread1874470.html
  //
  Occupant()
      : m_name(nullptr)
      , m_surname(nullptr)
      , m_phone(nullptr)
  {};
 
  // Конструктор с параметрами.
  // Не забываем про const!!!
  // Тогда мы имеем полное право писать:
  //   Occupant o("Ivan", "Petrov", "+79993334455");
  // Т.к. строка "Ivan" (и др.) - это константы.
  Occupant(const char *name, const char *surname, const char *phone);
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  //
  // ПРАВИЛО ТРЁХ
  //  https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D1%82%D1%80%D1%91%D1%85_(C%2B%2B)
  //
  // Если явно реализовали:
  //  - деструктор,
  //  - конструктор копирования или
  //  - оператор присваивания копированием.
  // То необходими реализовать и все оставшиеся.
 
  // Деструктор для очистки памяти
  ~Occupant();
 
  // Конструктор копирования
  Occupant(const Occupant &other);
 
  // Оператор присваивания копированием
  Occupant & operator=(const Occupant &other);
 
  // P.S.
  // Начиная с C++11 появляется ПРАВИЛО ПЯТИ
  //  https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D1%82%D1%80%D1%91%D1%85_(C%2B%2B)
  // "Но это уже совсем другая история"
 
  // Сеттеры:
  //
  // Не забываем про const
  // и красивые имена параметров.
  void setName(const char *name);
 
  void setSurname(const char *surname);
 
  void setPhone(const char *phone);
 
  // Геттеры:
  //
  // Не забываем про const:
  //
  // +-------- Возвращаем константную строку
  // |         которую нельзя менять!!!
  // |
  // |                    +---- Метка того, что этот метод не меняет объект.
  // |                    |     Без неё нельзя вызвать эти методы,
  // |                    |     если к нам пришёл const Occupant
  // |                    |     Например, в конструкторе копирования.
  // V                    V
  const char * getName() const
  {
    return m_name;
  }
 
  const char * getSurname() const
  {
    return m_surname;
  }
 
  const char * getPhone() const
  {
    return m_phone;
  }
 
  // Остальное к объекту не относиться.
  // Выносим их из класса.
};
 
// Вспомогательная функция очистки строки.
// Передаём двойной указатель,
// что бы могли напрямую работать с исходной переменной
// (задать исходной переменной значение nullptr).
static void clear_str(char **str)
{
  if (*str) {
    delete[] * str;
    *str = nullptr;
  }
}
 
// Вспомогательная функция копирования строки.
// ВНИМАНИЕ: Не проверяет пункт назначения.
// Передаём двойной указатель,
// что бы могли напрямую работать с исходной переменной.
static void unsafe_copy_str(char **dst, const char *src)
{
  size_t N = strlen(src) + 1;
  *dst     = new char[N];
  memcpy(*dst, src, N);
}
 
// Вспомогательная функция замены строки.
// Передаём двойной указатель,
// что бы могли напрямую работать с исходной переменной.
static void rewrite_str(char **dst, const char *src)
{
  clear_str(dst);
  unsafe_copy_str(dst, src);
}
 
Occupant::Occupant(const char *name, const char *surname, const char *phone)
{
  unsafe_copy_str(&m_name, name);
  unsafe_copy_str(&m_surname, surname);
  unsafe_copy_str(&m_phone, phone);
}
 
Occupant::~Occupant()
{
  clear_str(&m_name);
  clear_str(&m_surname);
  clear_str(&m_phone);
}
 
Occupant::Occupant(const Occupant &other)
{
  unsafe_copy_str(&m_name, other.getName());
  unsafe_copy_str(&m_surname, other.getSurname());
  unsafe_copy_str(&m_phone, other.getPhone());
}
 
Occupant & Occupant::operator=(const Occupant &other)
{
  rewrite_str(&m_name, other.getName());
  rewrite_str(&m_surname, other.getSurname());
  rewrite_str(&m_phone, other.getPhone());
  return *this;
}
 
void Occupant::setName(const char *name)
{
  rewrite_str(&m_name, name);
}
 
void Occupant::setSurname(const char *surname)
{
  rewrite_str(&m_surname, surname);
}
 
void Occupant::setPhone(const char *phone)
{
  rewrite_str(&m_phone, phone);
}
 
void long_print(const Occupant &occupant)
{
  const char *name = occupant.getName();
  if (!name) name = "";
  const char *surname = occupant.getSurname();
  if (!surname) surname = "";
  const char *phone = occupant.getPhone();
  if (!phone) phone = "";
  std::cout << "Name: " << name << ", ";
  std::cout << "Surname: " << surname << ", ";
  std::cout << "Phone: " << phone << std::endl;
}
 
int main()
{
  Occupant o = Occupant("Ivan", "Petrov", "+79993334455");
  long_print(o);
  return 0;
}

#include <iostream>
#include <string>
 
class Occupant {
  // В С++ есть класс std::string
  std::string m_name;
  std::string m_surname;
  std::string m_phone;
 
public:
  Occupant(const std::string &name,
           const std::string &surname,
           const std::string &phone)
      : m_name(name)
      , m_surname(surname)
      , m_phone(phone)
  {
  }
 
 
  // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
  //
  // ПРАВИЛО НУЛЯ
  //  https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%B2%D0%B8%D0%BB%D0%BE_%D1%82%D1%80%D1%91%D1%85_(C%2B%2B)
  //
  // И нам не надо думать о деструкторе и прочем.
 
  void setName(const std::string &name)
  {
    m_name = name;
  }
 
  void setSurname(const std::string &surname)
  {
    m_surname = surname;
  }
 
  void setPhone(const std::string &phone)
  {
    m_phone = phone;
  }
 
  const std::string &getName() const
  {
    return m_name;
  }
 
  const std::string &getSurname() const
  {
    return m_surname;
  }
 
  const std::string &getPhone() const
  {
    return m_phone;
  }
};
 
 
void long_print(const Occupant &occupant)
{
  std::cout << "Name: " << occupant.getName() << ", ";
  std::cout << "Surname: " << occupant.getSurname() << ", ";
  std::cout << "Phone: " << occupant.getPhone() << std::endl;
}
 
Occupant read_occupant() {
  std::string name;
  std::string surname;
  std::string phone;
 
  std::cout << "Please, enter occupant fields:\n";
  std::cout << "Name: ";
  std::getline(std::cin, name);
  std::cout << "Surname: ";
  std::getline(std::cin, surname);
  std::cout << "Phone: ";
  std::getline(std::cin, phone);
 
  return Occupant(name, surname, phone);
}
 
int main()
{
  Occupant o1 = Occupant("Ivan", "Petrov", "+79993334455");
  Occupant o2 = read_occupant();
 
  long_print(o1);
  long_print(o2);
 
  return 0;
}