Please help regarding new and delete

[rasmidas]

Here is the lines of code. Here new has been used bot not delete.
Is it correct or we need to do some code change. Please let me know.
Your help is highly appreciated. Thanks.

int  IsSwapClearable ( const sTRADE* pSummitTrade )
{
cout<<"INSIDE IsSwapClearable()"<<endl;
   try
   {
      int retval = sFALSE;
 
      CheckSwapClear* mySwapClearChecks = new CheckSwapClear();
 
      // must be a mapped counterparty so do not call IsSwapClearCounterparty();
 
      if ( mySwapClearChecks->IsSwapClearMappedCounterparty ( pSummitTrade->Base.Env->Cust.Name ) == sTRUE )
      {
         switch ( pSummitTrade->Base.TradeType )
         {
            case sTT_SWAP :
                 retval = mySwapClearChecks->IsSwapClearableSwap ( pSummitTrade );
                 break;
            default :
                 break;
         }
      }
cout<<"EXITING IsSwapClearable()"<<endl;
      return retval;
   }
   catch( DmgException& aExcep )
   {
      mLogMessage ( "EXCEPTION caught in IsSwapClearable()" );
cout<<"EXITING A IsSwapClearable()"<<endl;
      throw;
   }
   catch ( ... )
   {
      mLogMessage ( "Unknown Exceptions caught in IsSwapClearable()" );
cout<<"EXITING B IsSwapClearable()"<<endl;
      throw;
   }
}
 

[Banfa]

The new operates on a user defined type CheckSwapClear. It is probably that this type is a class and in that case it is possible that this class keeps track of all new'd/instantiated items via the use of static member variables in which case it may be OK for the item to be new'd here without being deleted.

ON the other hand the CheckSwapClear class may not keep track of new'd/instantiated items in which case the new without delete would be a memory leak.

[ravenspoint]

To make that clearer: Yes, you need to use delete.

Easier, would be to make it an automatic.

Instead of

CheckSwapClear* mySwapClearChecks = new CheckSwapClear();
 
...
 
mySwapClearChecks->IsSwapClearMappedCounterparty
 

write

CheckSwapClear mySwapClearChecks ;
 
...
 
mySwapClearChecks.IsSwapClearMappedCounterparty
 

Now the compiler will look after garbage collection automatically.

[weaknessforcats]

CheckSwapClear* mySwapClearChecks = new CheckSwapClear();

...

mySwapClearChecks->IsSwapClearMappedCounterparty

This is the correct thing to do. However, mySwapClearChecks should be a handle. See the C/C++ Article on Handle Classes. Using the heap is preferred over the stack as stack memory is often limited plus the compiler has conrtrol over deleting and not you. With the heap, you have control over deleting but you have to know when to do it. That is where the handle(smart pointer) comes in.

One of the worst things you can do in a C++ program is pass pointers around.

[ravenspoint]

It is best to let the compiler look after deletion, wherever possible, since it saves a great deal of strain on the old brain.

The point about using up stack space does have to be considered. If you have a monster class that uses large amounts of memory, then creating it on the stack with an automatic variable may be problematical. The solution is that they should allocate their own memory ( in the constructor ) and do their own garbage collection ( in the destructor ) - in this way they can be created on the stack without grabbing all the stack memory and still leave the compiler with the chore of deciding when to do garbage collection. The snag is you now have to be careful about copy constructors.

Trying to outhink the compiler is a mugs game!

[weaknessforcats]

It is best to let the compiler look after deletion, wherever possible, since it saves a great deal of strain on the old brain.

Except this doesn't work. True, the compiler will look aftrer deletion and will delete the object when it goes out of scope. But it does not check to see if there are any pointers in the program that still point to the object. If there are, then when those pointers are used later, the program crashes.

The only way to get this to work is to make all of the objects global so they are deleted after main() completes. But this doesn't wwork either because there are limits on global space.

Further, stack objects such as arrays have to be sized at compile time. In actual practice, an array needs to be sized at run time.

All roads lead to the heap. Allocation and deletion of heap objects should involve create functions and handles.