如何使 function 参数在 C++ 中单行传递之前和之后执行某些操作

Question

I would like to make an object do something before and after being passed as an argument into a function, but (1) without modifying the function and (2) in a neat way.

Here is the first one that comes to my mind, with RAII. However, I think the expression (x.lock(), x) is ugly.

I think there would definitely be a good solution, but I can't think of one.

#include <iostream>
using namespace std;

// I can change this class
struct RAII {
  RAII() {
    cout << "do sth globally" << endl;
  }
  ~RAII() {
    cout << "revert it" << endl;
  }
};

class A {
  public:
    // I can change this function, too.
    auto lock() {
      return RAII();
    }
};

void f(const A& obj) {
  cout << "a function that I can't change" << endl;
}

int main() {
  A x;
 // I think the expression is somewhat ugly.
 // Can I make this a more neat one-liner, like f(x.locked())?
  f((x.lock(), x));
}

The output is the same as below.

do sth globally
a function that I can't change
revert it

Answer 1

You cannot do it when the function and call are:

void f(const A& obj);
f(x);

and you are not allowed to change these. There is no way to make the object aware of a reference being taken.

You can however, call a different function:

void f2(const A& obj) {
     obj.before();
     f(obj);
     obj.after();
}

f2(x); // <- one line

With RAII that would be something along the line of

struct helper {
      const A& obj;
      helper(const A& obj) : obj(obj) { before(obj); }
      ~helper() { after(obj); }
};

void f2(const A& a) {
    helper h{a};
    f(a);
}

Answer 2

Wrapping the function doesn't work for you?

#include <iostream>

class A {
  public:
    void preProc() const {
        std::cout<<"Pre-proc\n";
    }
    void postProc() const {
        std::cout<<"Post-proc\n";
    }
};

struct RAII {
  explicit RAII(const A& a): a_(a){
    a_.preProc();
  }
  ~RAII() {
    a_.postProc();
  }
  private:
  const A& a_;
};

void f(const A& a){

}

void fWrap(const A& a){
    RAII r(a);
    f(a);
}

int main() {
    A a;
    fWrap(a);
}

Obviously this is just more convenience over just writing a.preProc() and a.postProc() every time before the function call. If it's just a single instance, the entire RAII class can just be removed!

Edit:

My motivation for RAII was perhaps a bit myopic. As @largest_prime_is_463035818 rightly adds, if f() actually threw an exception, the ~RAII() would be called, allowing cleanup of anything that had been set up in the a.preProc() which isn't available in the vanilla function-wrap scenario.