# 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:

```cpp
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:

```cpp
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:

```cpp
#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: 

```cpp
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
}
```