template<class T>
    T Stack<T>::Pop() noexcept(std::is_nothrow_move_constructible_v<T>)
{
    if (vused_ == 0)
        internal_program_error("pop from empty stack");

    try
    {
        return std::move_if_noexcept(v_[--vused_]);
    }
    catch (...)
    {
        ++vused_;
        throw;
    }
}

template <class F>
    class scope_exit_wrapper
{
public:
    scope_exit_wrapper(F &&f) :
        m_f(std::forward<F>(f)) {}
    ~scope_exit_wrapper()
    {
        m_f();
    }
    scope_exit_wrapper(scope_exit_wrapper const &) = delete;
private:
    F m_f;
};

template <class F>
    class scope_success_wrapper
{
public:
    scope_success_wrapper(F &&f) :
        m_f(std::forward<F>(f)),
        m_uncaught_exceptions(std::uncaught_exceptions())
    {}
    ~scope_success_wrapper() noexcept(false)
    {
        if (std::uncaught_exceptions() == m_uncaught_exceptions)
            m_f();
    }
    scope_success_wrapper(scope_success_wrapper const &) = delete;
private:
    F m_f;
    int m_uncaught_exceptions;
};

struct scope_exit_wrapper_arg_t {};
struct scope_success_wrapper_arg_t {};

template <class F>
    scope_exit_wrapper<F> operator <<(scope_exit_wrapper_arg_t, F &&f)
        { return {std::forward<F>(f)}; }
template <class F>
    scope_success_wrapper<F> operator <<(scope_success_wrapper_arg_t, F &&f)
        { return {std::forward<F>(f)}; }

#define PP_CONCAT_IMPL(x1, x2) x1##x2
#define PP_CONCAT(x1, x2) PP_CONCAT_IMPL(x1, x2)

#define SCOPE_EXIT(...)                                               \
    [[maybe_unused]] auto &&PP_CONCAT(SCOPE_EXIT_VAR_, __LINE__) =    \
        scope_exit_wrapper_arg_t() << [__VA_ARGS__]() noexcept -> void

#define SCOPE_SUCCESS(...)                                            \
    [[maybe_unused]] auto &&PP_CONCAT(SCOPE_SUCCESS_VAR_, __LINE__) = \
        scope_success_wrapper_arg_t() << [__VA_ARGS__]() -> void

template<class T>
    T Stack<T>::Pop() noexcept(std::is_nothrow_move_constructible_v<T>)
{
    if (vused_ == 0)
        internal_program_error("pop from empty stack");

    if constexpr (std::is_nothrow_move_constructible_v<T>)
    {
        SCOPE_EXIT(&){ v_[vused_].~T(); };
        return std::move(v_[--vused_]);
    }
    else
    {
        SCOPE_SUCCESS(&){ v_[--vused_].~T(); };
        return v_[vused_ - 1];
    }
}

T t = stack.pop();

T const &t = stack.pop();

stack.pop().member_function();

variable = stack.pop().data_member;

auto &&t = stack.pop();

auto t = stack.pop();

T t = std::move(stack.top());
POTENTIALLY_THROWING_EXPRESSION;
use_value(t);
stack.pop();

void f1(T t);
void f2(const T& t);
void f3(T&& t);

template<typename U>
void f4(U&& t) {}

int main() {
  T t;
  t = stack.pop(); // 1
  f1(stack.pop()); //2
  f2(stack.pop()); //3
  f3(stack.pop()); //4
  f4(stack.pop()); //5
}

....
— If the initializer expression is an rvalue, with T2 a class type, and “cv1 T1” is reference-compatible with “cv2 T2,” the reference is bound in one of the following ways (the choice is implementation-defined):

    — The reference is bound to the object represented by the rvalue (see 3.10) or to a subobject within that object.

    — A temporary of type “cv1 T2” [sic] is created, and a constructor is called to copy the entire rvalue object into the temporary. The reference is bound to the temporary or to a subobject within the temporary. [Footnote: Clearly, if the reference initialization being processed is one for the first argument of a copy constructor call, an implementation must eventually choose the first alternative (binding without copying) to avoid infinite recursion.]

....
— If the initializer expression

    — is an xvalue, class prvalue, array prvalue or function lvalue and “cv1 T1” is reference-compatible with “cv2 T2”, or

    — has a class type (i.e., T2 is a class type), where T1 is not reference-related to T2, and can be implicitly converted to an xvalue, class prvalue, or function lvalue of type “cv3 T3”, where “cv1 T1” is reference-compatible with “cv3 T3”,

then the reference is bound to the value of the initializer expression in the first case and to the result of the conversion in the second case (or, in either case, to an appropriate base class subobject). ....

— If the initializer expression

(5.2.1.1) — is an rvalue (but not a bit-field) or function lvalue and “cv1 T1” is reference-compatible with “cv2 T2”, or

(5.2.1.2) — has a class type (i.e., T2 is a class type), where T1 is not reference-related to T2, and can be converted to an rvalue or function lvalue of type “cv3 T3”, where “cv1 T1” is reference-compatible with “cv3 T3” (see 16.3.1.6),

then the value of the initializer expression in the first case and the result of the conversion in the second case is called the converted initializer. If the converted initializer is a prvalue, its type T4 is adjusted to type “cv1 T4” (7.5) and the temporary materialization conversion (7.4) is applied. In any case, the reference is bound to the resulting glvalue (or to an appropriate base class subobject).

template<class T>
T Stack<T>::Pop() {
  if( vused == 0 )
    return T();
  else
    return v_[vused--];
}

template <class T> class Stack {
  T Pop();
private:
  T*     v_;      // ptr to a memory area big
  size_t vsize_;  //  enough for 'vsize_' T's
  size_t vused_;  // # of T's actually in use
};

template<class T>
T Stack<T>::Pop()
{
  if( vused_ == 0)
    throw "pop from empty stack";

  T result = v_[vused_-1];
  --vused_;

  try {
    return result;
  } catch (...) {
    ++vused_;
    throw;
  }
}

В C++17 наличие нового исключения можно обнаружить с помощью std::uncaught_exceptions, а в более ранних плюсах такой функции нету.

auto top_value = stack.pop();

#define SCOPE_EXIT(...)                                               \
    [[maybe_unused]] auto &&PP_CONCAT(SCOPE_SUCCESS_VAR_, __LINE__) = \

#define SCOPE_EXIT(...)                                               \
    [[maybe_unused]] auto &&PP_CONCAT(SCOPE_EXIT_VAR_, __LINE__) = \

void f1(T t);
void f2(const T& t);
void f3(T&& t);

template<typename U>
void f4(U&& t) {}

int main() {
  T t;
  t = stack.pop(); // 1
  f1(stack.pop()); //2
  f2(stack.pop()); //3
  f3(stack.pop()); //4
  f4(stack.pop()); //5
}

class Stack {
public:
   T pop();
};

T t = stack.pop();