Как создать функцию с надежной гарантией исключения?

Решение состоит в использовании защиты области действия.

См. этот ответ для примера их реализации; Я не буду здесь повторяться. С охранниками области ваш код будет выглядеть так:

vector1.push_back(/*...*/);
FINALLY_ON_THROW( vector1.pop_back(); )
vector2.push_back(/*...*/);
FINALLY_ON_THROW( vector2.pop_back(); )
vector3.push_back(/*...*/);
FINALLY_ON_THROW( vector3.pop_back(); )
vector4.push_back(/*...*/);
FINALLY_ON_THROW( vector4.pop_back(); )

Здесь FINALLY_ON_THROW — это макрос (см. ссылку выше). Вместо немедленного выполнения этого параметра он вызывает его выполнение, когда вы покидаете текущую область действия из-за исключения. Если вместо этого вы покинете область обычным способом, параметр будет проигнорирован. Если вы покинете прицел до того, как управление дойдет до охранника, оно также будет проигнорировано.

Учтите, что последний гард лишний, если после него (в том же прицеле) ничего не может бросить.

Проблема с простым возвратом заключается в том, что он не обязательно вернет вектор в исходное состояние. Если добавление элемента вызвало перераспределение любого из векторов, то итераторы/ссылки на элементы будут признаны недействительными, и эта недействительность не может быть отменена, что делает невозможным надежную гарантию исключения.

Безопасным, простым и общим решением является внесение изменений в копию. Копирование, конечно же, требует дополнительных затрат.

void some_function() {
    auto copy = *this;
    copy.vector1.push_back(/*...*/); // May Throw
    copy.vector2.push_back(/*...*/); // May Throw
    copy.vector3.push_back(/*...*/); // May Throw
    copy.vector4.push_back(/*...*/); // May Throw
    *this = std::move(copy);
}

Предложение HolyBlackCat для защиты области действия является элегантным решением в тех случаях, когда возможен откат, например, если вы использовали другой контейнер, который не делает недействительным итераторы/ссылки, или если вас просто не волнует инвалидация, или если у вас есть инвариант класса, который предотвращает вызов функции, когда емкость заполнена.

Вы могли бы реально и с минимальными дополнительными затратами сначала проверить, все ли векторы имеют дополнительную емкость, и выбрать между копированием и откатом на основе проверки. Это позволяет вызывающему абоненту не оплачивать стоимость копирования, если он заранее резервирует достаточную емкость. Однако это далеко от элегантности.

Вы можете сделать это разными способами... Например, так:

#include <vector>
#include <type_traits>
#include <exception>


template<class F>
struct on_fail
{
    F   f_;
    int count_{ std::uncaught_exceptions() };

    ~on_fail()
    {
        // C++20 is here and still no easy way to tell "unwinding" and "leaving scope" apart
        if (std::uncaught_exceptions() > count_) f_();
    }
};

template<class F> on_fail(F) -> on_fail<F>;


auto emplace_back_x(auto& v, auto&& x)
{
    v.emplace_back(std::forward<decltype(x)>(x));
    return on_fail{[&v]{ v.pop_back(); }};
}


int bar();


template<class F>
struct inplacer
{
    F f_;
    operator std::invoke_result_t<F&>() { return f_(); }
};

template<class F> inplacer(F) -> inplacer<F>;


void foo()
{
    std::vector<int> v1, v2, v3;
    auto rollback1 = emplace_back_x(v1, 1);
    auto rollback2 = emplace_back_x(v2, inplacer{ bar });
    auto rollback3 = emplace_back_x(v3, inplacer{ []{ return bar() + 1; } });
}

Обратите внимание, что ваш пример неверен: если push_back() терпит неудачу с std::bad_alloc (или любым другим исключением) - вы не можете выполнить шаг отмены.

Также, возможно, в вашем случае имеет смысл использовать базовую гарантию? На практике вы часто можете иметь дело с этим на более высоком уровне - например. отключиться и сбросить все накопленное состояние, оставив клиенту возможность повторно подключиться и повторить попытку.

Как насчет этого?

class X {
   /* Fields and stuff */
   void some_function() {
       vector1.push_back(/*...*/); // May Throw
       try {
           vector2.push_back(/*...*/); // May Throw
           try {
               vector3.push_back(/*...*/); // May Throw
               try {
                   vector4.push_back(/*...*/); // May Throw
               } catch(...) {
                   vector3.pop_back();
                   throw;
               }
           } catch(...) {
               vector2.pop_back();
               throw;
           }
       } catch(...) {
           vector1.pop_back();
           throw;
       }
   }
};

Но... вам действительно нужны 4 разных вектора?

class X {
   /* Fields and stuff */
   void some_function() {
       vector1234.push_back(std::make_tuple(/*...*/, /*...*/, /*...*/, /*...*/)); // May Throw
   }
};