# V1062. Class defines a custom new or delete operator. The opposite operator must also be defined.

This diagnostic rule is based on the R.15 CppCoreGuidelines rule.

A class defines a custom 'new' or 'delete' operator but does not define the opposite operator.

Example:

    class SomeClass
    {
      ....
      void* operator new(size_t s);
      ....
    };

Objects of this class will be dynamically allocated using the overloaded 'new' operator and deleted using the default 'delete' operator.

For symmetry of allocation/deallocation operations, define the 'delete' operator as well:

    class SomeClass
    {
      ....
      void* operator new(size_t s);
      void operator delete(void*);
      ....
    };

You can also mark operators as deleted ('= delete') if for some reason you need to prevent allocation or deallocation of objects of this class. Try to prevent both allocation and deallocation at the same time, so that calling either of these operators would cause a compile-time error rather than a hard-to-see bug:

    #include <cstddef>

    class AutoTransaction
    {
    public:
        /// Mark 'operator new' as deleted to prevent heap allocation
        void* operator new (std::size_t) = delete;
    };

    void foo()
    {
      auto ptr = new AutoTransaction; // code doesn't compile
    }

    void bar()
    {
      AutoTransaction obj;
      delete &obj;         // code compiles, but contains an error
    }

If you prevent the deallocation in the same way, the compiler will not let the error occur:

    class SomeClass
    {
      ....
      void* operator new(size_t s) = delete;
      void operator delete(void*) = delete;
      ....
    };

    void foo()
    {
      auto ptr = new AutoTransaction; // code doesn't compile
    }

    void bar()
    {
      AutoTransaction obj;
      delete &obj;         // code doesn't compile
    }

This diagnostic is classified as:

CWE-762

You can look at examples of errors detected by the V1062 diagnostic.