vanyamba-electronics

Просто у вас ошибка в этой строке
MyString MyString::Copy(const char *string) { }
Вы возвращаете копию объекта. Он нигде не используется:

MyString::MyString(const char *string)
{
  Copy(string); // Вот здесь
}

И для этой копии вызывается деструктор.

А должно быть так:
MyString& MyString::Copy(const char *string) { }
В этом случае метод вернёт ссылку на объект.

Но тогда вам следует объявить этот метод как статичный и назвать его не "копировать", а "создать":

class MyString {
   MyString(const char* string);
   static MyString* Create(const char *string);
};

MyString::MyString(const char *string)
{
  m_length = StrLen(string);
  m_string = new char[m_length + 1];

  if (m_string != nullptr) {
     for (size_t i = 0; i < m_length; ++i)
       m_string[i] = string[i];

       m_string[m_length] = '\0';
   }
}
   
MyString* MyString::Create(const char *string)
{
  return new MyString(string);
}

Обратите внимание - мой метод возвращает указатель. Это такое правило - никогда не возвращайте по ссылке объект, который создаётся внутри функции. Иначе потом будете рефакторить весь код.

В C++ нет стандартного соглашения, как должен поступить компилятор с объектом, возвращённым из функции по ссылке. Одни компиляторы такие объекты просто тихо удаляют, другие - нет.
И вот, у вас объект в памяти есть, вы его не удаляли, и он даже доступен. Всё работает.
Но потом вы создаёте какой-то новый объект, и у вас крашится программе при попытке доступа к прошлому объекту.
Что такое? Почему компилятор сгенерил код, который затирает память? Куда подевался объект в том месте программы, в котором раньше всё работало?
Просто физически нереально отыскать место возникновения ошибки через неделю, за которую вы написали ещё 30 тысяч строк кода.
Поэтому всегда возвращайте объект из функции только по указателю.

#include <iostream>

using namespace std;

typedef enum {
    NotEqual,
    Less,
    Equal,
    Greater
} CompareResult;

template <typename _T>
struct CF {
    typedef CompareResult (*CompareFunc)(const _T&, const _T&);
};

template <typename _T>
class avl_tree
{
protected:
    typename CF<_T>::CompareFunc m_cf;
public:
    avl_tree(typename CF<_T>::CompareFunc func) : m_cf(func), m_tree(nullptr) {}
};

CompareResult compare_int(const int& item1, const int& item2)
{
    if (item1 < item2)
        return Less;
    if (item1 > item2)
        return Greater;
    return Equal;
}

int main()
{
    avl_tree<int> int_tree(compare_int);
    return 0;
}

Я также попробовал реализовать это дерево, но в нём нет строгой логики. Всё прекрасно, когда элементов 3. Но когда встаёт задача вставить четвёртый, то возникает вопрос, какую форму должна принять эта структура. А правило говорит, что ветви, исходящие от верхнего элемента должны различаться по высоте не более, чем на единицу.
Ну, допустим, что у нас 4 элемента. Можно изъять из дерева 1 элемент, из трёх выбрать верхний и как-то вставить четвёртый. Теоретически должно работать, но на практике такое решение может привести к тому, что будут варианты бесконечного изъятия лишних элементов, чтобы вставить их куда-то.
Нужно строгое правило, чтобы этого не происходило.

void error(const char* msg) {
   throw msg;
}
...
try {
   if (! fs.is_open())
       error("Can't open file.");
}
catch (const char* msg) {
  cerr << "Error: " << msg << endl;
}

#include <iostream>

using namespace std;

typedef enum {
    Key1 = 1,
    Key2 = 2,
    Key4 = 4,
    Key8 = 8
} Key;

void func(uint32_t keys)
{
    if (keys & 1)
        cout << "Key1 ";
    if (keys & 2)
        cout << "Key2 ";
    if (keys & 4)
        cout << "Key4 ";
    if (keys & 8)
        cout << "Key8 ";
    cout << endl;
}

int main()
{
    func(Key1 | Key4 | Key8);
    return 0;
}