Inheriting from CString caused out of memory exception

Question

I have the following string class that inherits from MFC CString

class TString : public CString
{
public:
    TString() : CString(_T(""))
    {
    }

    TString(LPCTSTR str) : CString(str)
    {
    }
};

I had an out of memory exception in a method that used the + operator with TString frequently, so I tried to make a test like the following

TString str;
TCHAR buffer[] = "Hello world, Hello world, Hello world, Hello world, Hello world, Hello world";

uint i = 0;
while(i++ < 100000000)
{
    str = buffer;
    str += buffer;
}

that took a lot of memory and ended with out of memory exception this is a shot for the memory change from the task manager after the last code was executed

when I replaced the TString with the CString it was normal took the time and no out of memory exception and the memory was stable in task manager as in this shot

I tried the following 2 states

1. I created another exe application that depend on the same Library that contain the TString class it worked very fine like CString
2. I caled Sleep(1) inside the while loop and it gave to rapid change in the memory and was stable also What can I do to fix such a problem??

EDIT:

There were some wrong in my explanation when I recompiled the solution CString also had the same behaviour even the std::string I thought the new operator overloading I created a custom class that call the malloc and free at the destructor it also lead to the same behaviour, I moved that test code to the first entry point in my application to constructor of my application that inherits from CWinAppEx the code worked fine then I looked at the InitInstance I found a memory leak detection 4 lines of code as the following

int tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
tmpDbgFlag |= _CRTDBG_DELAY_FREE_MEM_DF;//<====this is the evil after comment everything is fine
tmpDbgFlag |= _CRTDBG_LEAK_CHECK_DF;
_CrtSetDbgFlag(tmpDbgFlag);

I always know that it's a human mistake. That cause disasters.

I just commented the line

tmpDbgFlag |= _CRTDBG_DELAY_FREE_MEM_DF;

That solved it. this answer also talk about the usage of this flag Finding heap corruption I thank everyone tried to help in this problem, I hope that it will help.

Answer 1

Inheriting from a class that does not have a virtual destructor is a very bad idea anyway. The following is a quote from "Effective C++: 55 Specific Ways to Improve Your Programs and Designs, Third Edition" by Scott Meyers.

The problem is that getTimeKeeper returns a pointer to a derived class object (e.g., AtomicClock), that object is being deleted via a base class pointer (i.e., a TimeKeeper* pointer), and the base class (TimeKeeper) has a non-virtual destructor. This is a recipe for disaster, because C++ specifies that when a derived class object is deleted through a pointer to a base class with a non-virtual destructor, results are undefined. What typically happens at runtime is that the derived part of the object is never destroyed. If a call to getTimeKeeper happened to return a pointer to an AtomicClock object, the AtomicClock part of the object (i.e., the data members declared in the AtomicClock class) would probably not be destroyed, nor would the AtomicClock destructor run. However, the base class part (i.e., the TimeKeeper part) typically would be destroyed, thus leading to a curious “partially destroyed” object. This is an excellent way to leak resources, corrupt data structures, and spend a lot of time with a debugger.

To summarize, when you derive from a class that does not have a virtual destructor, you then make use of a pointer to that object, the object is only partially destroyed when you delete that pointer. This apparently only happens when the pointer is to the base class and not when the pointer is to the class itself.

If you must extend a class that does not have a virtual destructor, it is best to do it by containment. That is create a new class that is not derived from the class you wish to extend. Then have a member variable of the type that you wish to extend and implement all of the functions in the class you wish to extend as wrappers around the appropriate function in the class you wish to extend.

For example.

class TString /* do not derive from CString */
{
private:
  CString m_string;
    TString() :
      m_string()
  {
  }

  TString(const TCHAR *str) :
    m_string(str)
  {
  }

  int GetLength() const
  {
    return m_string.GetLength();
  }

  /* All the other functions in the CString class here. */

  /* Your additions to the CString class here. */
}

Of course in recent versions of MFC CString is actually a template class so you should perhaps make your class a template class as well as follows.

template< typename BaseType >
class TStringT
{
    /* The same as above but use BaseType instead of TCHAR. */
}

Then do the following.

typedef TStringT< wchar_t > TStringW;
typedef TStringT< char > TStringA;
typedef TStringT< TCHAR > TString;

I hope this helps.

Answer 2

This may not be the answer to your problem but give it a try.

Add following method to your TString class:

TString& operator=(LPCTSTR src)
{
    CString::operator=(src);

    return( *this );
}

This will speed up the assignment of a TString from a LPTSTR such as str = buffer;. Without that method assignment of a TString from a LPTSTR will construct a temporary TString before doing the assignment. If you step through the assignment with a debugger you will see.