As long as the debugging tools that detect leaks are not standardized (not saying they should), it would be strange to have a standard feature to announce that it is a deliberate leak.

How about just using the already provided standard features. Use a special separate allocator for deliberate leaks and the debugging tools distinguish the leaks by allocator?
 

-----Ursprüngliche Nachricht-----
Von: Frederick Virchanza Gotham via Std-Proposals <std-proposals@lists.isocpp.org>
Gesendet: Fr 11.10.2024 13:12
Betreff: [std-proposals] Deliberate memory leak
An: std-proposals <std-proposals@lists.isocpp.org>;
CC: Frederick Virchanza Gotham <cauldwell.thomas@gmail.com>;
There are times when we allocate memory which we never intend to
deallocate. For example, I'm writing a program at the moment that
loads in plugins, and the plugins stay loaded until the end of the
program.

The only problem with this is that when you run a debugging tool to
detect memory leaks, you get a load of false positives. I had a
program before that linked with libpango, and I spent ages trying to
find a memory leak, wondering if I was misusing the library or if the
library internally had a bug, and I went the whole hog and joined the
libpango mailing list and shared all my debugging output. In the end
it turned out to be a benign memory leak -- i.e. the allocation
happened once in the program and was intended to last the entire
program.

But what if we could do the following:

   void *p = malloc( 1024ul * 1024ul * 64ul );
   std::deliberate_leak(p);

Or:

   long unsigned *p = new long unsigned[2048u];
   std::deliberate_leak(p);

It could work something like this:    https://godbolt.org/z/Gx6Pc6ne5

And then when you compile in Release Mode, you don't bother deallocating.

And here it is copy-pasted:

#include <cstdlib>      // abort, atexit, free
#include <mutex>        // lock_guard, mutex

#define PRINT_TO_SCREEN // ------- You can comment this line out -------

#ifdef PRINT_TO_SCREEN
#   include <cstdint>   // uintptr_t
#   include <iomanip>   // hex
#   include <iostream>  // cout, endl
#endif

void DeliberateLeak(void const volatile *const arg) noexcept
{
   constexpr unsigned capacity = 64u;
   static void const volatile *leaks[capacity] = {};  // all nullptr's

   static std::mutex m;
   std::lock_guard mylock(m);

   if ( nullptr == leaks[0u] )
   {
       std::atexit(
           [](void) noexcept -> void
           {
               for ( unsigned i = 0u; i < capacity; ++i )
               {
                   if ( nullptr == leaks[i] ) return;
                   std::free( const_cast<void*>(leaks[i]) );
#ifdef PRINT_TO_SCREEN
                   std::cout << "Freeing deliberately leaked memory
at address 0x"
                             << std::hex
                             << reinterpret_cast<std::uintptr_t>(leaks[i])
                             << std::endl;
#endif
               }
           });
   }

   static unsigned index = 0u;
   if ( index >= capacity ) std::abort();  // no more free slots available
   leaks[index++] = arg;
}

int main(void)
{
   void *p1 = std::malloc(1024ul * 1024ul * 64ul);
   DeliberateLeak(p1);
   void *p2 = std::malloc(1024ul * 1024ul * 64ul);
   DeliberateLeak(p2);
}
--
Std-Proposals mailing list
Std-Proposals@lists.isocpp.org
https://lists.isocpp.org/mailman/listinfo.cgi/std-proposals