void MyFun()
{
    std::vector<MyClass1*> v1;
    std::list<MyClass2*> v2;
    ...
    std::map<MyClassN*, MyClassN1*> vN;
    
    //дальше идет тяжелая работа с коллекциями, где создаются и добавляются в эти коллекции экземпляры
    //MyClass1..MyClassN, при этом в любой момент может выскочить исключение
}

std::vector<std::unique_ptr<MyClass1> >

__>>std::vector<std::unique_ptr<MyClass1> >
__>>

template<typename value_type>
    class vector_of_pointed_values: public std::vector<value_type*>
    {
    public:
        //---
        virtual
            ~vector_of_pointed_values(void)
        {
            //<код удаления>
        }
        //---
    };

__>template<typename value_type>
__>    class vector_of_pointed_values: public std::vector<value_type*>
__>    {
__>    public:
__>        //---
__>        virtual
__>            ~vector_of_pointed_values(void)
__>        {
__>            //<код удаления>
__>        }
__>        //---
__>    };

__>

int a1, aN;
//...
MyClass1* p1;
//...
if(a1 == 0)
    p1->send1();
else
    p1->send2();

delete p1;
//...
MyClassN* pN;
//...
if(aN == 1000)
    pN->send3();
else
    pN->send5();

delete pN;

void launch_work_threads()
    {
        work_thread_t * started_threads[ total_priorities_count ];
        fill( begin(started_threads), end(started_threads), nullptr );

        do_with_rollback_on_exception( [&] {
            for( std::size_t i = 0; i != total_priorities_count; ++i )
                {
                    m_agents_per_priority[ i ].store( 0, std::memory_order_release );

                    m_threads[ i ]->start();

                    started_threads[ i ] = m_threads[ i ].get();
                }
            },
            [&] {
                invoke_noexcept_code( [&] {
                    for( auto t : started_threads )
                        if( t )
                            {
                                t->shutdown();
                                t->wait();
                            }
                        else
                            break;
                } );
            } );
    }

template<class T, class D>
auto make_unique_ptr(T* p, D d) { return std::unique_ptr<T,D>(p,d); }

.....

std::vector<X*> v;
std::list<Y*> l;
std::map<Z*,T*> m;
 
auto vcleaner = make_unique_ptr(&v,
    [](auto pv) {
        for(auto item : *pv) delete item;
    }
);
 
auto lcleaner = make_unique_ptr(&l,
    [](auto pv) {
        for(auto item : *pv) delete item;
    }
);
 
auto mcleaner = make_unique_ptr(&m,
    [](auto pm) {
        for(const auto& kv : *pm) { // pair<T* const, U*> kv
            delete kv.first;
            delete kv.second;
        }
    }
);

.....

// отпускаем, не удаляя
lcleaner.release();
vcleaner.release();
mcleaner.release();
return;

void foo(vector<X*>& resultX, list<Y*> resultY) {
  my_vector_scope_guard gX(&resultX);
  my_list_scope_guard   gY(&resultY);
  ....
  resultX.push_back(new X);
  resultY.push_back(new Y);
  ....
  gX.release(); // отказываемся от ролбека
  gY.release();
}

void bar(vector<X*>& result, list<Y*> resultY) {
  my_owning_vector<X*> tmpX;
  my_owning_list<Y*>   tmpY;
  ....
  tmpX.push_back(new X);
  tmpY.push_back(new Y);
  ....
  tmpX.swap(resultX); // коммит
  tmpY.swap(resultY);
}

K>void MyFun()
K>{
K>    std::vector<MyClass1*> v1;
K>    std::list<MyClass2*> v2;
K>    ...
K>    std::map<MyClassN*, MyClassN1*> vN;
    
K>    //дальше идет тяжелая работа с коллекциями, где создаются и добавляются в эти коллекции экземпляры
K>    //MyClass1..MyClassN, при этом в любой момент может выскочить исключение
K>}
K>

void MyFun()
{
    std::vector<MyClass1> v1;
    // и никаких сложностей с ручным управлением памятью
    // зато получаем локальность данных в случае с std::vector
}

в функции используется АПИ, требующее ссылок типа std::vector<MyClass1*>

void FunA(int a, int b, int c)
{
    try
    {
        //код функции
    }
    catch(...)
    {
        FunAFinally(a, b, c);
        throw;
    }
    FunAFinally(a, b, c);
}

void FunAFinally(int a, int b, int c)
{
    //код финализатора
}