Чому змінюється довжина?

#include <cstdlib>
#include <iostream>
#include <cstdio>

class MyString
{
public:
    int length;
    char *str;
    MyString::MyString(char* str)
    {
        MyString::str = str;
        RecalcLength();
    }
    friend std::ostream& operator<<(std::ostream& os, const MyString& ms);

    void operator+=(char* str)
    {
        int length = MyString::length + strlen(str); 
        char *s = new char[length];
        for (int i = 0; i < MyString::length; i++)
        {
            s[i] = MyString::str[i];
        }
        for (int i = 0; i < strlen(str); i++)
        {
            s[i + MyString::length] = str[i];
        }

        std::cout << "Length before equating: " << strlen(MyString::str) << std::endl;
        MyString::str = s;
        std::cout << "Length after equating: " << strlen(MyString::str) << std::endl;
        MyString::length = length;
    }
private:
    void RecalcLength()
    {
        MyString::length = strlen(MyString::str);
    }
};

std::ostream& operator<<(std::ostream& os, const MyString& ms)
{
    os << ms.str;
    return os;
}

int main()
{
    MyString mys = "abc";
    std::cout <<"Length before += is: " << mys.length << std::endl;
    mys += "aaa";
    std::cout << "Length after += is: " << mys.length << std::endl;
    std::cout << "mys is: " << mys<< std::endl;

    system("pause >> void");
}

p.s. круто я придумав, ага?

Мм, так то delete походу тре викликати перед new, бо new виділяє пам'ять в новій області якісь, ага?
Компуляктору норм.
Так, боюсь. (до того ж це так круто)

це термінатор?

Змінив char str[], на вказівник char* str, хотів запропонувати, але подумав що ти сам до цього дійдеш. Взагалі молодець.
Тепер зауваження.

1. Про ініціалізацію об’єктів. Запам’яти просто, якщо ти ініціюєш змінну без new, то вона живе до виходу за межі її видимості.

{
  {
    int aaa;
    ...
  }
  // тут змінної вже aaa і не видно і її немає, вона знищена
}

Але якщо ти використовуєш операцію new, то змінна розташовується в "кучі" (це така область пам’яті) і тобі повертається вказівник на цю змінню в кучі.

{
  {
    int* bbb = new (int);
    ...
    // тут ти может дістатися створеного об’єкта в кучі через вказівник bbb
  }
  // тут вже bbb не видно, але об’єкт в кучі залишився, бо ти його не видалив
}

якщо тобі вже не потрібен об’єкт, створенний оператором new, його потрібно видалити оператором delete, інакше пам’ять в кучі так і залишиться занятою.
Правило просте - new і delete завжди ходять в парі. Якщо об’єкт створюється за допомогою оператора new то він повинен знищуватись за допомогою оператора delete. Для знащиення масива, створеного за допомогою new, використовуються оператор delete[], не плутати!

{
  {
    int* bbb = new (int);
    ...
    // тут ти может дістатися створеного об’єкта в кучі через вказівник bbb
    delete bbb; // вказівник ще є, але об’єкт на який він вказує вже знищено
  }
  // тут вже bbb не видно, але об’єкт в кучі залишився, бо ти його не видалив
}

2. Стрічки C-типу (що являють собою массив char) по-хорошому повинні закінчуватися на символ "термінальний нуль" - '\0', бо саме цей символ вважається кінцем стрічки в багатьох операціях і в << в тому числі. Тому, коли ти з’єднуєш дві свої стрічки то розмір роби на одиницю більшим і в кінець став термінальний нуль. В тебе такий розмір дивний і виходить бо strlen шукає термінальний нуль в массиві і їй байдуже що він закнічився.

Це основні зауваження.

На бутер вже є. Навіть з ікрою. З кількома ікринками 

то ви забули видалити

// тут вже bbb не видно, але об’єкт в кучі залишився, бо ти його не видалив

в третьому коді?

Я хз, що то є.

Про RAII.
Якщо ми створюємо об’єкт за допомогою операції new, то ми повинні обов’язково знищити його за допомогою операції delete. Інакше буде "протічка" пам’яті, чи як там. Є кілька причин по яким ми можемо не знищити об’єкт:

• 1. банальна неуважність - забули

• 2. якийсь неопрацьований ексепшин при якому переривається робота програми

• 3. багато виходів з метода і не перед всіма викликається delete

• 4. інші причини, які я не можу зараз згадати.

Ось так все непросто з цим new.

А от якщо створювати об’єкт без new, то правило лише одне - він автоматично знищується коли виконання програми виходить за межі його видимості. І неважливо яким саме чином, неважливо був ексепшин чи ні - він знищується, пам’ять вивільняється і точка.

Тут виникає питання - а чи можна зробити так щоб об’єкти, які створюються операцією new поводили себе схожим чином?
Можна, якщо new-об’єкти "загорнути" в звичайні локальні об’єкти. Локальними я називаю об’єкти, які існують тільки в певній області видимості.

Логіка така:

• 1. ми створюємо свій new-об’єкт в конструкторі звичайного об’єкта

• 2. і знищуємо його оператором delete в дестукторі цього об’єкта.

При ініціалізації локального об’єкта викликається його конструктор і створюється наш new-об’єкт в кучі. Потім при виході за область видимості, неважливо по якій причині, локальний об’єкт знищується, а для цього викликається його деструктор. Деструктор в свою чергу знищує new-об’єкт оператором delete.

Використовуючи такий підхід нам не треба паритись про то що ми десь залишимо невивільнену пам’ять.

class MyCharArray{
private:
  char* _array;
public:
  MyCharArray( int );
  ~MyCharArray();
};

MyCharArray::MyCharArray( int size ) {
  _array = new char [ size ];
  std::cout << "array created" << std::endl;
}

MyCharArray::~MyCharArray() {
  delete[] _array;
  std::cout << "array deleted" << std::endl;
}

int main( int argc, char **argv ) {
  MyCharArray a( 10 );  
  return 0;
}

output:
array created
array deleted

Ось в цій ідеї і полягає техніка RAII. Її і використовують розумні вказівники auto_ptr, shared_ptr, weak_ptr...

З.И. Якшо я десь налажав то поправте, будь-ласка. Я можу

Мені чомусь здається що деструктор силою викликати тут було поганою ідеєю

Додай до деструктора якийсь вивід, виведе два рази.