Что произойдет в конструкторе при вызове оператора new, если возникнет исключение? Есть ли риск утечки памяти в этом случае?

При возникновении исключения в конструкторе объекта, вызываемого через оператор new, оператор new освободит память, выделенную для этого объекта, прежде чем перебросить исключение. Это поведение гарантируется стандартом C++.

Риск утечки памяти в данном конкретном случае, касающемся памяти, выделенной самим оператором new для объекта, отсутствует.

Однако, если в конструкторе были выделены другие ресурсы (например, динамическая память через new для членов класса, открыты файловые дескрипторы и т.д.), и их освобождение не было корректно обработано до возникновения исключения, риск утечки этих дополнительных ресурсов существует.

Для предотвращения утечек ресурсов в случае исключений в конструкторах используются следующие подходы:

1. RAII (Resource Acquisition Is Initialization): Ресурсы связываются со временем жизни объекта, и при уничтожении объекта (в том числе при раскрутке стека из-за исключения) ресурс автоматически освобождается.

   class Resource {
   public:
       Resource() { /* получение ресурса */ }
       ~Resource() { /* освобождение ресурса */ }
   };
   
   class MyClass {
       Resource res; // res будет уничтожен при выходе из конструктора по исключению
       int* data;
   public:
       MyClass() : res() {
           data = new int[10];
           // ... может возникнуть исключение ...
           // если здесь исключение, data не будет удален без try/catch или умного указателя
       }
       ~MyClass() {
           delete[] data;
       }
   };
   

2. Умные указатели: Используются для автоматического управления динамической памятью.

   #include <memory>
   
   class MyClass {
       std::unique_ptr<int[]> data;
   public:
       MyClass() {
           data = std::make_unique<int[]>(10);
           // ... может возникнуть исключение ...
           // unique_ptr освободит data автоматически
       }
       // ~MyClass() не нужен для unique_ptr
   };
   

3. Блоки try-catch внутри конструктора (менее предпочтительно): Позволяет перехватить исключение и освободить ресурсы перед перебросом или обработкой.

   class MyClass {
       int* data1;
       int* data2;
   public:
       MyClass() : data1(nullptr), data2(nullptr) {
           try {
               data1 = new int[10];
               // ... может возникнуть исключение после new data1
               data2 = new int[20];
               // ... может возникнуть исключение после new data2
           } catch (...) {
               delete[] data1; // Освобождение data1
               delete[] data2; // Освобождение data2 (если было выделено)
               throw; // Переброс исключения
           }
       }
       ~MyClass() {
           delete[] data1;
           delete[] data2;
       }
   };
   

Этот последний подход усложняет код и менее безопасен, чем RAII или умные указатели, так как требует тщательного отслеживания выделенных ресурсов в каждом блоке catch.

В итоге, сам new гарантирует освобождение памяти под объект при исключении в конструкторе, но ответственность за освобождение других ресурсов лежит на разработчике, и наилучшим способом для этого является использование RAII и умных указателей.