A Simple String Class

  1. #pragma once
  3. #include <iostream>
  4. #include <cstring>
  6. class MyString
  7. {
  8. private:
  9.     int buf_len;
  10.     char *characters;
  12. public:
  13.     MyString(int buf_len = 64, const char *data = NULL)
  14.     {
  15.         std::cout << "Constructor(int, char*)" << std::endl;
  16.         this->buf_len = 0;
  17.         this->characters = NULL;
  18.         create(buf_len, data);
  19.     }
  20.     ~MyString()
  21.     {
  22.         delete[] this->characters;
  23.     }
  24.     bool create(int buf_len, const char *data)
  25.     {
  26.         this->buf_len = buf_len;
  28.         if (this->buf_len != 0)
  29.         {
  30.             this->characters = new char[this->buf_len]{};
  31.             if (data)
  32.                 strncpy(this->characters, data, this->buf_len);
  33.         }
  35.         return true;
  36.     }
  37.     friend std::ostream &operator<<(std::ostream &os, const MyString &ms)
  38.     {
  39.         os << "buf_len = " << ms.buf_len;
  40.         os << ", characters = " << static_cast<void *>(ms.characters);
  41.         os << " [" << ms.characters << "]";
  42.         return os;
  43.     }
  44. };

采用动态内存，再构造函数中申请内存，再析构函数中释放内存，是不是就万事大吉呢？我们运行一下程序

  1. #include <iostream>
  2. #include "mystring.hpp"
  4. using namespace std;
  6. // Why memory leak and memory double free?
  7. int main()
  8. {
  9.     MyString str1(10, "Shenzhen");
  10.     cout << "str1: " << str1 << endl;
  12.     MyString str2 = str1;  // 调用了copy constructor，str1和str2 指向的相同的内存空间
  13.     cout << "str2: " << str2 << endl;
  15.     MyString str3;  // 调用了默认的构造函数，
  16.     cout << "str3: " << str3 << endl;
  17.     str3 = str1;  // 这时赋值操作，编译器会生成=的运算符重载，把str1的成员拷贝给str2
  18.     cout << "str3:" << str3 << endl;
  20.     return 0;
  21. }

Video_2021-12-12_131534.wmv这时这三个对象指向的内存空间相同，再程序即将完成退出之前，要执行析构函数对他们的内存销毁，执行完一个对象内存销毁之后，再进行第一个对象内存销毁时，就会出错。再str3创建的时候，会开辟一块内存空间，但是当str3 = str1之后，str3的变量characters修改了内存地址，所以没有变量指向这块内存地址，就会造成内存泄漏。

这种内存泄漏的bug非常难排查。那么应该如何避免呢？