перегрузка оператора new и delete, обнаружение утечки памяти

Question

требуется, чтобы я обнаружил утечку памяти в исходном коде.

для этого. В исходном коде есть два флага, связанных с тестом на утечку памяти.

1) _ENABLE_NEW_MEM_DELETE_TRACE 2) TRACK_RUNTIME_MEM_LEAKS оба флага включены в make-файл, если есть какая-либо утечка в коде, эти флаги помогут создать текстовый файл и упомянуть количество утечек байтов,

, чтобы проверить, что я намеренно создаю утечку, int * ptr = новый int (10); * ptr = 100; я не удаляю указатель, поэтому это приведет к утечке памяти, но он не создает ожидаемый текстовый файл

из анализа, я обнаружил, что он не входит в функцию перегрузки void * operator new (size_t iSize), пожалуйста, имейте цикл в коде и дайте мне знать, что мне не хватает

enter code here 

          void* operator new(size_t iSize)
             {
                // calling the global operator results in recusion !
                // it still calls the overridden function
                 //::operator new(iSize);
                   cout<<"mem leak ------Operator new"<<endl;
                    void * ptr = NULL;
                  try
                   {
                    ptr = malloc(iSize);
                       if(NULL != ptr)
                        {
                           LogNew(ptr, iSize);
                          }
                         else
                         {
                     g_bIsInitialized = false;
                     // This mandatory throw is according to:
                     // http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=40
                     throw std::bad_alloc(); // ANSI/ISO compliant behavior
                      //cerr << __FILE__ << " " << __LINE__ << " Made NULL memory " << __func__                                <<endl;
                   }
               }
                catch(...)
                   {
                   g_bIsInitialized = false;
                 //cerr << __FILE__ << " " << __LINE__ << " Exception rethrown in " << __func__        << endl;
                 throw; // re-throw
                   }
                   return(ptr);
                  } // new


 ``````
  void* operator new(size_t iSize)
          {
          // calling the global operator results in recusion !
             // it still calls the overridden function
               //::operator new(iSize);
              cout<<"mem leak ------Operator new"<<endl;
             void * ptr = NULL;
                 try
                  {
                    ptr = malloc(iSize);
                    if(NULL != ptr)
                     {
                       LogNew(ptr, iSize);
                     }
                    else
                     {
                     g_bIsInitialized = false;
       
                      throw std::bad_alloc(); // ANSI/ISO compliant behavior
                    //cerr << __FILE__ << " " << __LINE__ << " Made NULL memory " << __func__ << endl;
                   }
                 }
                 catch(...)
                   {
                   g_bIsInitialized = false;
                   //cerr << __FILE__ << " " << __LINE__ << " Exception rethrown in " << __func__ << endl;
                      throw;    // re-throw
                      }
                  return(ptr);
               }    // new



           void* operator new [](size_t iSize) //__attribute__((always_inline))
            {
   
                cout<<"mem leak ------Operator new"<<endl;
                  void * ptr = NULL;
                   try
                   {
                    ptr = malloc(iSize);
                    if(NULL != ptr)
                      {
                         LogNew(ptr, iSize);
                       }
                    else
                    {
                       g_bIsInitialized = false;
                  
                          throw std::bad_alloc(); // ANSI/ISO compliant behavior
       
                     }
                  }
              catch(...)
                 {
                      g_bIsInitialized = false;
                     //cerr << __FILE__ << " " << __LINE__ << " Exception rethrown in " << __func__ << endl;
                  throw;    // re-throw
                     }
                  return(ptr);
                   }    //new[]

              void operator delete(void* iPtr)
                  {

                      cout<<"mem leak -----delete"<<endl;
                     try
                      {
                        LogDelete(iPtr);

                        // calling the global operator results in recusion !
                          // it still calls the overridden function
                       //::operator delete(iPtr);
                         free(iPtr);
                        }
                      catch(...)
                     {
                         g_bIsInitialized = false;
                         //cerr << __FILE__ << " " << __LINE__ << " Exception rethrown in " << __func__ << endl;
                          throw;  // re-throw
                        }
                      }   //delete
 

 /**
  * @brief overridden delete[] operator. Frees memory and tracks usage
  * @param[in] iPtr - the pointer to a previously new'ed object
  */
 void operator delete [](void* iPtr)
 {
    try
    {
       LogDelete(iPtr);
       // calling the global operator results in recusion !
       // it still calls the overridden function
       //::operator delete[](iPtr);
       free(iPtr);
    }
    catch(...)
    {
       g_bIsInitialized = false;
       //cerr << __FILE__ << " " << __LINE__ << " Exception rethrown in " << __func__ << endl;
       throw; // re-throw
    }
 }  //delete[]
 
```````