Best C++ macro for creating a new scope - c++

Question

I have a macro
#define SCOPE_GUARD(GUARD, NAME, ...) \
for(bool __once = true; __once; /* nothing */) \
for(GUARD NAME (__VA_ARGS__); __once; __once = false)
using something like this:
SCOPE_GUARD(std::unique_lock, lock, (some_mutex))
do_some();
or
SCOPE_GUARD(std::unique_ptr<char>, buff, (new char[BUFFER_SIZE])) {
*buff.get() = 0;
GetSomeDescription(buff.get(), BUFFER_SIZE);
Log(buff.get);
}
Are there similar(better) implementation of the macro, which is optimized by multiple compilers correctly.
P.S. Macro should be one, without finally macro like BOOST_SCOPE_EXIT_END (can redefine by if (...)).
EDIT
Simple scoupe in using codestyle is very huge.
{
std::unique_lock lock (some_mutex);
do_some();
}
but I want using some like this
SCOPE_GUARD(std::unique_lock, lock, (some_mutex)) do_some();

Answer 1

You can do an awful lot with C++ templates and lambda expressions. It might be worthwhile to explore using them. For example, instead of using the SCOPE_GUARD macro, you could do something like this:
template <typename G, typename F, typename... A>
inline auto scope_guard(G&&, F&& f, A&&... args)
-> decltype(std::forward<F>(f)(std::forward<A>(args)...))
{
return std::forward<F>(f)(std::forward<A>(args)...);
}
scope_guard(std::unique_lock<std::mutex>(m), do_something);
scope_guard(std::unique_lock<std::mutex>(m), [&]() {
do_something1();
do_something2();
do_something3();
});
If I were using straight macros, mine would probably look something like this:
#define UNWRAP(...) __VA_ARGS__
#define SCOPE_GUARD(X, Y) do { X; UNWRAP Y; } while (0)
SCOPE_GUARD(std::unique_lock<std::mutex> lock(m), (do_something()));
SCOPE_GUARD(std::unique_lock<std::mutex> lock(m), (
do_something1();
do_something2();
do_something3();
));

Answer 2

I think this is what you're looking for:
#define PROTECTED_BY(m) for(std::unique_lock<decltype(m)> _lock_(m) ; _lock_ ; _lock_.unlock())
complete use case:
#include <iostream>
#include <mutex>
#define PROTECTED_BY(m) for(std::unique_lock<decltype(m)> _lock_(m) ; _lock_ ; _lock_.unlock())
using namespace std;
int main()
{
mutex m;
PROTECTED_BY(m)
{
cout << "Hello World" << endl;
}
return 0;
}