Ошибка выполнения 0xC0000005

// custom_String v0.3
 
#define __CLASS_GETTER__(type, name, var) const type name(void) const { return var; }
#define __CLASS_GETTER_STATIC__(type, name, var) static type name(void) { return var; }
 
#include <iostream>
#include <concepts>
#include <cstring>
 
namespace custom {
 
#define __SAME_CHAR__(type) std::same_as<type, T>
template<typename T>
concept Character = 
    __SAME_CHAR__(char)   ||
    __SAME_CHAR__(wchar_t);
#undef __SAME_CHAR__
 
template<Character T>
class BasicString {
    public:
        BasicString(void);
        BasicString(int size);
        BasicString(const T* inputStr);
        BasicString(const BasicString &other);
        ~BasicString(void);
 
        __CLASS_GETTER__(T*, c_str, str);
        __CLASS_GETTER__(size_t, size, length);
        __CLASS_GETTER_STATIC__(uint16_t, count, strCount);
 
        BasicString<T>& operator=(const BasicString<T>& other);
        BasicString<T>& operator=(const T* inputStr);
        operator T*() { return str; };
 
        static friend std::basic_istream<T>& operator>>(std::basic_istream<T> &is, BasicString<T> &str) { return is.getline(str.str, str.length+1); }
        static friend std::basic_ostream<T>& operator<<(std::basic_ostream<T> &os, const BasicString<T> &str) { return os << str.str; }
 
    private:
        size_t strlen(const T* str);
        void strcpy(T* dest, const rsize_t size, const T* src);
        void deepCopy(const BasicString<T>& other);
 
        T* str;
        size_t length;
        static uint16_t strCount;
};
 
using String = BasicString<char>;
using WString = BasicString<wchar_t>;
 
using std::cout;
 
template<Character T>
uint16_t BasicString<T>::strCount = 0;
 
template<Character T>
BasicString<T>::BasicString(void) : BasicString(80) {}
 
template<Character T>
BasicString<T>::BasicString(int size) : length(size) {
    str = new T[length+1];
    str[0] = '\0';
    ++strCount;
    cout << strCount << std::endl;
}
 
template<Character T>
BasicString<T>::BasicString(const T* inputStr) {
    length = strlen(inputStr);
    str = new T[length+1];
    strcpy(str, length+1, inputStr);
    ++strCount;
    cout << strCount << std::endl;
}
 
template<Character T>
BasicString<T>::BasicString(const BasicString &other) {
    deepCopy(other);
    ++strCount;
    cout << strCount << std::endl;
}
 
template<Character T>
BasicString<T>::~BasicString() {
    delete[] str;
    --strCount;
    cout << strCount << std::endl;
}
 
template<Character T>
BasicString<T>& BasicString<T>::operator=(const BasicString& other) {
    if (this != &other) {
        delete[] str;
        deepCopy(other);
    } return *this;
}
 
template<Character T>
BasicString<T>& BasicString<T>::operator=(const T* inputStr) {
    delete[] str;
    length = strlen(inputStr);
    str = new T[length+1];
    strcpy(str, length+1, inputStr);
    cout << strCount << std::endl;
}
 
template<Character T>
inline size_t BasicString<T>::strlen(const T *str) { return std::strlen(str); }
 
template<>
inline size_t BasicString<wchar_t>::strlen(const wchar_t *str) { return std::wcslen(str); }
 
template<Character T>
inline void BasicString<T>::strcpy(T *dest, const rsize_t size, const T *src) { std::strcpy(dest, size, src); }
 
template<>
inline void BasicString<wchar_t>::strcpy(wchar_t *dest, const rsize_t size, const wchar_t *src) { wcscpy_s(dest, size, src); }
 
template<Character T>
void BasicString<T>::deepCopy(const BasicString &other) {
    length = other.length;
    str = new T[length+1];
    std::memcpy(str, other.str, (length+1) * sizeof(T));
}
 
} // end namespace custom
 
#undef __CLASS_GETTER__
#undef __CLASS_GETTER_STATIC__
 
 
 
// main
 
#include <iostream>
#include <locale>
 
void initDefaultLocale(void) {
    #ifdef _WIN32
        auto loc = std::locale("Russian_Russia.1251"); 
        std::wcin.imbue(loc);
        std::wcout.imbue(loc);     
    #else
        auto loc = std::locale("ru_RU.UTF-8");
        std::locale::global(loc); 
    #endif  
}
 
class Person {
    public:
        Person(custom::WString name = L"");
        Person(const Person& other);
 
        Person& operator=(const Person& other);
 
        static friend std::wostream& operator<<(std::wostream &os, const Person &person) { return os << person.name; }
 
    private:
        custom::WString name;
};
 
Person::Person(custom::WString name) : name(name) {}
 
Person::Person(const Person& other) : name(other.name) {}
 
Person& Person::operator=(const Person &other) {
    if (this != &other) { name = other.name; }
    return *this;
}
 
class Apartment {
    public:
        Apartment();
        Apartment(const Apartment& other);
        ~Apartment();
 
        void operator+=(const Person& person);
 
        void displayResidents() const;
 
    private:
        Person* residents;
        int residentCount;
};
 
Apartment::Apartment() : residents(nullptr), residentCount(0) {}
 
Apartment::Apartment(const Apartment& other) {
    residentCount = other.residentCount;
    residents = residentCount > 0 ? new Person[residentCount] : nullptr;
    if (residents) { for (int i = 0; i < residentCount; ++i) residents[i] = other.residents[i]; }
}
 
Apartment::~Apartment() { delete[] residents; }
 
void Apartment::operator+=(const Person& person) {
    Person* newResidents = new Person[residentCount + 1];
    for (int i = 0; i < residentCount; ++i) { newResidents[i] = residents[i]; }
    newResidents[residentCount] = person;
    delete[] residents; // ОШИБКА ВЫПОЛНЕНИЯ ЗДЕСЬ
    residents = newResidents;
    ++residentCount;
}
 
void Apartment::displayResidents() const {
    std::wcout << "Жильцы квартиры:" << std::endl;
    for (int i = 0; i < residentCount; ++i) { std::wcout << "|- " << residents[i] << std::endl; }
}
 
class Building {
    public:
        Building(int count);
        Building(const Building& other);
        ~Building();
 
        void addResidentToApartment(int apartmentIndex, const Person& person);
        void displayApartments() const;
 
    private:
        Apartment* apartments;
        int apartmentCount;
};
 
Building::Building(int count) : apartmentCount(count), apartments(new Apartment[apartmentCount]) {}
 
Building::Building(const Building& other) {
    apartmentCount = other.apartmentCount;
    apartments = new Apartment[apartmentCount];
    for (int i = 0; i < apartmentCount; ++i) { apartments[i] = other.apartments[i]; }
}
 
Building::~Building() { delete[] apartments; }
 
void Building::addResidentToApartment(int apartmentIndex, const Person& person) {
    if (apartmentIndex >= 0 && apartmentIndex < apartmentCount) apartments[apartmentIndex] += person;
    else std::cerr << "Invalid apartment index." << std::endl;
}
 
void Building::displayApartments() const {
    for (int i = 0; i < apartmentCount; ++i) {
        std::wcout << "Квартира " << (i + 1) << ":" << std::endl;
        apartments[i].displayResidents();
    }
}
 
int main() {
    initDefaultLocale();
 
    Building building(3);
 
    Person person1(L"Иван Иванов");
    Person person2(L"Мария Петрова");
    Person person3(L"Петр Сидоров");
 
    building.addResidentToApartment(0, person1);
    building.addResidentToApartment(0, person2);
    building.addResidentToApartment(1, person3);
 
    building.displayApartments();
}

for (int i = 0; i < apartmentCount; ++i) { apartments[i] = other.apartments[i]; }

for (int i = 0; i < residentCount; ++i) { newResidents[i] = residents[i]; }

// Было
Building::Building(int count) : apartmentCount(count), apartments(new Apartment[apartmentCount]) {}
// Стало
Building::Building(int count) : apartmentCount(count) {
    apartments = new Apartment[apartmentCount];
}

 if (residents != nullptr) {
       delete[] residents;
   }

Person* newResidents = new Person[residentCount + 1];

void Apartment::operator+=(const Person& person) {
    Person* newResidents = new Person[residentCount + 1];
    for (int i = 0; i < residentCount; ++i) { newResidents[i] = residents[i]; }
    newResidents[residentCount] = person;
    delete[] residents; // ОШИБКА ВЫПОЛНЕНИЯ ЗДЕСЬ
    residents = newResidents;
    ++residentCount;
}