int f1();
int f2();
int f3();

int acc()
{   
  int rez;
  int r;
  if (!(r = f1())) return 0;
  rez += r;
  if (!(r = f2())) return 0;
  rez += r;
  if (!(r = f3())) return 0;
  rez += r;
  return rez;
}

  int rez = 0;

  auto _acc = [&](int r) -> bool {
    return r ? rez += r : 0;
  };

  return
      _acc(f1()) &&;
      _acc(f2()) &&;
      _acc(f3()) ? rez : 0;

• В твоём варианте с if пропущена инициализация переменной rez. То есть тут UB. А компилятор же просто удаляет всю логику суммирования, но при этом следит за порядком вызовов функций f1,f2,f3 — так как именно там находятся пути, приводящие к return 0, то есть к веткам независящим от мусора в rez;
  
• Условие !(r = f2()) прекращает вычисления если f2 вернула 0. В твоём же варианте с лямбдами условие другое: r ? rez += r : 0, то есть вычисления заканчиваются и в том случае, если сумма стала нулевой (рассмотри, например, случай f1() == -5, f2() == 5).

class
t_AccumulateWhileNonZeroImpl
{
    #pragma region Fields

    protected: int & m_sum;
    protected: bool  m_continue = true;

    #pragma endregion

    private:
    t_AccumulateWhileNonZeroImpl(void) = delete;

    private:
    t_AccumulateWhileNonZeroImpl(t_AccumulateWhileNonZeroImpl const &) = delete;

    private:
    t_AccumulateWhileNonZeroImpl(t_AccumulateWhileNonZeroImpl && other) throw()
    :    m_sum(other.m_sum)
    {
        // do nothing...        
    }

    private: explicit
    t_AccumulateWhileNonZeroImpl(int & sum) throw()
    :   m_sum(sum)
    {
        m_sum = 0;
    }

    private: auto
    operator =(t_AccumulateWhileNonZeroImpl const &) -> void = delete;

    private: auto
    operator =(t_AccumulateWhileNonZeroImpl &&) -> void = delete;

    public: template<typename tp_Method> auto
    operator ,(tp_Method & method) -> t_AccumulateWhileNonZeroImpl &
    {
        if(m_continue)
        {
            auto const method_result(method());
            m_continue = (0 != method_result);
            m_sum += method_result;
        }
        return(*this);
    }

    friend auto
    Accumulate_While_NonZero(int & sum) throw() -> t_AccumulateWhileNonZeroImpl;
};

auto
Accumulate_While_NonZero(int & sum) throw() -> t_AccumulateWhileNonZeroImpl
{
    return(t_AccumulateWhileNonZeroImpl(sum));
}

int Give_9(void) {return 9;}
int Give_0(void) {return 0;}

int sum;
Accumulate_While_NonZero(sum), Give_9, Give_9, Give_0, Give_9;
assert(18 == sum);

dad>int f1();
dad>int f2();
dad>int f3();

dad>int acc()
dad>{   
dad>  int rez;
dad>  int r;
dad>  if (!(r = f1())) return 0;
dad>  rez += r;
dad>  if (!(r = f2())) return 0;
dad>  rez += r;
dad>  if (!(r = f3())) return 0;
dad>  rez += r;
dad>  return rez;
dad>}
dad>

int acc() {
  int sum;
  for (auto f : {f1, f2, f3}) {
    auto n = f();
    if (n == 0) return 0;
    sum += n;
  }
  return sum;
}

int acc() {
  int r1, r2, r3;
  if ((r1 = f1()) && (r2 = f2()) && (r3 = f3()))
    return r1 + r2 + r3;
  return 0;
}

// в допущении, что аргументы положительные, и нет переполнения
int plus0(int acc, int x) {
  return acc && x ? acc + x : 0;
}
int seed() { return 1; }
int commit(int acc) { return acc ? acc-1 : 0; }

// без этого допущения
using boost::optional; // или std::experimental::optional;
                       // или переделать на std::pair<bool,int>
optional<int> plus0(optional<int> acc, int x) {
  return acc && x ? optional<int>(*acc + x) : optional<int>();
}
optional<int> seed() { return optional<int>(0); }
int commit(optional<int> acc) { return acc ? *acc : 0; }

....
int xs[] = { f1(), f2(), f3(), ..... };
return commit(std::accumulate(std::begin(xs), std::end(xs), seed(), plus0));

// чисто для упрощения
typedef int (*F)();

int plus0(int acc, F f) {
  if(!acc) return 0;
  int x = f();
  if(!x) return 0;
  return acc+x;
}
.....
F fs[] = { f1, f2, f3, ..... };
return commit(std::accumulate(std::begin(fs), std::end(fs), seed(), plus0));

int xs[] = { f1(), f2(), f3(), ..... }; // энергичный случай
F fs[] = { f1, f2, f3, ..... }; // ленивый случай

int acc = 0;
for(x : xs) {
  if(!x) { acc = 0; break; }
  acc += x;
}

for(f : fs) {
  int x = f();
  if(!x) { acc = 0; break; }
  acc += x;
}

// optional для бедных
bool ok = true;
int acc = 0;

#define ADD(expr)          \
  do {                     \
    if(ok)                 \
      if(int tmp = (expr)) \
        acc += tmp;        \
      else {               \
        acc = 0;           \
        ok = false;        \
      }                    \
  } while(false)

ADD(f1());
ADD(f2());
ADD(f3());

int acc;
#define BEGIN() do { acc = 0;
#define ADD(expr) if(tmp = (expr)) acc += tmp; else { acc = 0; break; }
#define END() while(false);

BEGIN()
  ADD(f1())
  ADD(f2())
  ADD(f3())
END()

int f()
{
   int r;
   int rez = 0;

   return true
      && (r = f1(), rez += r, r)
      && (r = f2(), rez += r, r)
      && (r = f3(), rez += r, r)
      ? rez : 0;
}

#include <boost/preprocessor/seq.hpp>

int f1();
int f2();
int f3();

#define FUNCS (f1)(f2)(f3)

int acc()
{
  int rez;
  int r;

#define PROCEED_FUNC(a, b, elem) \
  if (!(r = elem())) return 0; \
  rez += r;

  BOOST_PP_SEQ_FOR_EACH(PROCEED_FUNC,,FUNCS)

  return rez;
}