Проверка выделения памяти указателей через оператор new

var ***v;

v = new var**[1]; // создание 0-матрицы
if (v == NULL) // проверка выделения памяти для матрицы
    return -1;
v[0] = new var*[1]; // 0-массив
if (v == NULL)
    return -2;
v[0][0] = new var[3]; // 3 переменные
if (v == NULL)
    return -3;

v[0] = new var*[1]; // 0-массив
if (v[0] == NULL)
    return -2;
v[0][0] = new var[3]; // 3 переменные
if (v[0][0] == NULL)
    return -3;

new (std::nothrow) std::locale("Russian");

void some_large_function()
{
    //здесь может произойти 100500 разнообразных ошибок
    //память кончилась, файл не открылся, на Марсе песчаные бури, etc
}
int main()
{
    while(true)
    {
        try
        {
            some_large_function();
            break;
        }
        catch(...)
        {
            //что-то сбойнуло, перезапускаем
            cout<<"наша песня хороша, начинай сначала"<<endl;
        }
    }
}

catch(const std::exception&error)
{
    cout<<error.what()<<endl;
}

class A
{
//...
public:
   A operator/ ( int x ) const
   {
      if ( x != 0 )
         return A(this->b/x) ;
      //Как уведомите вызывающий код о том, что произошло деление на ноль?
   }
//...
} ;

//Title of this code
//Compiler Version 18.00.21005.1 for x86
 
#include <stdexcept>
#include <iostream>
#include <ctime>
 
using namespace std;
 
struct example
{
    ~example() 
    {
        cout<<"dtor\n";
        delete [] data; 
    }
    
    
    example(): data( new int[255] )   //<--- если полетит здесь, то утечек ресурсов не будет.
    {                              // Тем не менее, потенциальная дыра в безопасности.
        cout<<"ctor\n";
        
        static int seed(         //<--- гарантируется однократный вызов 
            ( srand(time(0)) ,0)  // при первом запуске конструктора  
        );
        (void)seed;
        
        const auto v = rand()%3;
        if(v==1)
            simulate_runtime_fault();
        else if(v==2)
            simulate_unkown_fault();
            
        
        
        
        // <--- ПОТЕНЦИАЛЬНАЯ УТЕЧКА РЕСУРСОВ.
        //       ИСПРАВИТЬ КОД!!!!
        
        //ИСТОРИЯ БОЛЕЗНИ:
        //объект, чей конструктор не был до конца завершен исчитается "недостроенным"
        //для недостроенных объектов диструктор вызван не будет.
        //следовательно никто не освободит память по указателю data
            
        //обратите внимание на количество конструкторов и количество диструкторов в консольном выводе.
        
        //ЛЕКАРСТВО:
        //1. Использовать RAII (отличный способ)
        //2. Ставить ловушки на всех местах потенциальных утечек (хороший способ)
        //3. Заложиться на то, что исключительных ситуаций не будет (говнокод)
    }
private:    
    static void simulate_runtime_fault()
    {
        throw ::std::runtime_error("simulation runtime fault");
    }
    static void simulate_unkown_fault()
    {
        throw ::std::string("simulation unkown fault");
    }
    
    int* data;
    
};
 
 
int main()
{
    
 
    std::cout << "Hello, world!\n";
    
    
    for(size_t n=0;n<10;++n)
    try{
        
        new(std::nothrow) example;
    }
    catch( const std::bad_alloc& e)
    {
        cout<<"Ошибка выделения памяти.\n";
        cout<<"MEMORY: "<<e.what()<<'\n';
        
        cout<<"Поиск захваченной памяти в пулах\n";
        cout<<"Дефрагментация пулов\n";
        cout<<"Успешное восстановление после паники\n";
    }
    catch( const std::exception& e )
    {
        cout<<"Известная ошибка: "<<e.what()<<'\n';
        cout<<"Успешное восстановление после паники\n";
    }
    catch( ... )
    {
        cout<<"Неопознанная ошибка. Перезапускаем модуль\n";
        cout<<"Успешное восстановление после паники\n";
    }
}

example(): data( new int[255] ) //<--- вот отсюда

for (size_t n = 0; n < 10; ++n) {
    try{
        new (std::nothrow) example;
    }
    catch( const std::bad_alloc& e )
    {
        // ...
    }
    catch( const std::exception& e )
    {
        // ...
    }
    catch( ... )
    {
        // ...
    }
}

#include <iostream>
#include <new>
 
class T {
  public:
    T()
    {
      throw 0; // предположим что тут бла-бла-бла сложные действия
    }
}; // class thrower
 
int main(int, char * []) {
  T * p = new (std::nothrow) T;
 
  if (p == NULL)
    std::cout << "new failed\n";
  else
    std::cout << "new succeed\n";
}

//Title of this code
//g++  4.8.2
 
#include <iostream>
 
struct example
{
    example()
    {
        throw ::std::bad_alloc(); //<--- симуляция сбоя
    }
};
 
int main()
{
    std::cout << "Hello, world!\n";
    
    auto* p = new(std::nothrow) example;
 
    //<---- до этой точки исполняющий процесс никогда не дойдет.
 
    if(p)                  
        std::cout << "success\n";
    else
        std::cout << "failed\n";
    
}

new(std::nothrow)