RAII: внутри функции и можно ли в ней заменить new?

BOOLEAN IsUserAdmin {
BOOLEN isAdmin = FALSE;
 
// здесь RAII для OpenProcessToken (CloseToken)
// и AllocateAndInitializeSid (FreeSid)
// как RAII объявить?
 
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &token)) {
   return err_code;
}
 
if (!GetTokenInformation(token, TokenGroups, NULL, 0, &buff_size &&
           ERROR_INSUFFICIENT_BUFFER != GetLastError()) {
   return err_code;
}
 
buff_size = new ...;
if (!GetTokenInformation(token, TokenGroups, token_groups, biff_size, &buff_size) {
   // высвободить память delete
   return err_code;
}
 
if (!AllocateAndInitializeSid(... &sid)) {
   return err_code;
}
 
// далее сравниваем Sid
for (int i = 0; i < token_groups->GroupsCount; i++) {
   if (EqualSid(sid, token_groups->Groups[i].Sid)) {
     isAdmin = TRUE;
     break;
   }
}
}

bool IsUserAdmin()
{
    auto_handle Token;
    
    if (!OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &Token)) {
        ThrowExc("OpenProcessToken failed, err = 0x%.8lx.", GetLastError());
    }
 
    DWORD ReqSize;
    
    if (GetTokenInformation(Token, TokenGroups, NULL, 0, &ReqSize)) {
        ThrowExc("GetTokenInformation #1 returns TRUE.");
    }
    
    DWORD const LastError = GetLastError();
    if (ERROR_INSUFFICIENT_BUFFER != LastError) {
        ThrowExc("GetTokenInformation #1 failed, err = 0x%.8lx.", LastError);
    }    
    
    DWORD const BuffSize = ReqSize;
    std::vector<byte> Buffer(BuffSize);
    
    if (!GetTokenInformation(Token, TokenGroups, &Buffer[0], BuffSize, &ReqSize)) {
        ThrowExc("GetTokenInformation #2 failed, err = 0x%.8lx.", GetLastError());
    }
    
    DWORD SidBuffSize = SECURITY_MAX_SID_SIZE;
    std::vector<byte> SidBuffer(SidBuffSize);
    
    if (!CreateWellKnownSid(WinBuiltinAdministratorsSid, NULL, &SidBuffer[0], &SidBuffSize)) {
        ThrowExc("CreateWellKnownSid failed, err = 0x%.8lx.", GetLastError());
    }
    
    TOKEN_GROUPS const * pInfo = reinterpret_cast<TOKEN_GROUPS *>(&Buffer[0]);
    DWORD const Count = pInfo->GroupCount;
    
    for (DWORD i = 0; i < Count; ++i)
    {
        if (pInfo->Groups[i].Attributes & (SE_GROUP_ENABLED | SE_GROUP_ENABLED_BY_DEFAULT))
        {
            if (EqualSid(pInfo->Groups[i].Sid, &SidBuffer[0]))
            {
                return true;
            }
        }
    }
    
    return false;
}

class auto_handle
{
public:
    auto_handle(HANDLE h = NULL) :
        m_h(h)
    {
    }
 
    ~auto_handle()
    {
        if ( (m_h) && (INVALID_HANDLE_VALUE != m_h) )
        {
            CloseHandle(m_h);
        }
    }
 
    operator HANDLE ()
    {
        return m_h;
    }
 
    HANDLE * operator & ()
    {
        return (&m_h);
    }
 
private:
    auto_handle(auto_handle const &);
    auto_handle & operator = (auto_handle const &);
 
private:
    HANDLE m_h;
};

bool IsUserAdmin()
{
    using namespace Security;
    
    safe_handle Token = openToken(tokenType::process, rights::tokenQuery);
    groups Groups = Token.getGroups();
    sid Sid = createSid(wellKnown::builtinAdmin);
    return (Groups.isPresent(Sid));
}

BOOL IsUserAdmin(void) {
  struct Res {
    HANDLE token;
    PSID   sid;
    
    Res() : sid(NULL), token(NULL) {}
    ~Res() {
      if (sid) FreeSid(sid);
      if (token) CloseHandle(token);
    }
  } res;
  
  BOOL status = FALSE;
  /* прочие переменные */
  
  if (!OpenProcessToken(
    GetCurrentProcess(), TOKEN_QUERY, &res.token
  )) return status;
  
  /* прочие вызовы */
}

//
// Auto.hpp
//
 
#pragma once
 
#include <Windows.h>
 
namespace Auto {
 
template <typename T, T INVALID> 
class AutoCleanup {
 
protected:
 
    AutoCleanup(T Res) : m_Res(Res) {}
 
public:  
 
    bool IsValid() const
    {
        return INVALID != m_Res;
    }
 
    operator T() const 
    { 
        ASSERT(true == IsValid());
        return m_Res; 
    }
 
    T* operator&()
    {
        ASSERT(false == IsValid());
        return &m_Res;
    }
 
    T operator=(T Res)
    { 
        ASSERT(false == IsValid());
        m_Res = Res;
        return m_Res;  
    }
 
    void Release()
    {
        ASSERT(true == IsValid());
        m_Res = INVALID;
    }
 
protected:
 
    T m_Res;
 
private:
 
    AutoCleanup(const AutoCleanup<T, INVALID>&);
    AutoCleanup<T, INVALID>& operator=(const AutoCleanup<T, INVALID>&);
};
 
//
// Simple classes
//
 
#define AUTO_CLEANUP_CLASS(FUNC, T, INVALID, NAME)          \
                                                            \
    struct NAME : public Auto::AutoCleanup<T, INVALID> {    \
                                                            \
        NAME(T Res = INVALID) : AutoCleanup(Res) {}         \
                                                            \
        ~NAME()                                             \
        {                                                   \
            if (IsValid()) {                                \
                FUNC(m_Res);                                \
            }                                               \
        }                                                   \
                                                            \
        T operator=(T Res)                                  \
        {                                                   \
            return AutoCleanup::operator=(Res);             \
        }                                                   \
    };
 
AUTO_CLEANUP_CLASS(::CloseHandle, HANDLE, NULL, AutoCloseHandle)
AUTO_CLEANUP_CLASS(::CloseHandle, HANDLE, INVALID_HANDLE_VALUE, AutoCloseFile)
AUTO_CLEANUP_CLASS(::CloseServiceHandle, SC_HANDLE, NULL, AutoCloseServiceHandle)
AUTO_CLEANUP_CLASS(::FreeLibrary, HMODULE, NULL, AutoFreeLibrary)
AUTO_CLEANUP_CLASS(::LocalFree, HLOCAL, NULL, AutoLocalFree)
AUTO_CLEANUP_CLASS(::UnmapViewOfFile, PVOID, NULL, AutoUnmapViewOfFile)
AUTO_CLEANUP_CLASS(::CloseDesktop, HDESK, NULL, AutoCloseDesktop)
AUTO_CLEANUP_CLASS(::CloseWindowStation, HWINSTA, NULL, AutoCloseWindowStation)
AUTO_CLEANUP_CLASS(::RegCloseKey, HKEY, NULL, AutoRegCloseKey)
 
//
// AutoVirtualFree
//
 
struct AutoVirtualFree : public AutoCleanup<PVOID, NULL> {
 
    AutoVirtualFree(PVOID Address = NULL, SIZE_T Size = 0, DWORD FreeType = MEM_RELEASE) 
    : 
    AutoCleanup(Address), m_Size(Size), m_FreeType(FreeType) {}
 
    ~AutoVirtualFree()
    {
        if (true == IsValid()) {
            ::VirtualFree(m_Res, m_Size, m_FreeType);
        }
    }
 
    HANDLE operator=(HANDLE Res)
    { 
        return AutoCleanup::operator=(Res);  
    }
 
private:
 
    const SIZE_T m_Size;
    const DWORD m_FreeType;
};
 
}; // namespace Auto

//
// ScreenCreator.cpp
//
 
    ...
 
#include "Auto.hpp"
 
#pragma comment(lib, "gdiplus.lib" )
 
using namespace Gdiplus;
using namespace Gdiplus::DllExports;
 
namespace Auto {
 
    AUTO_CLEANUP_CLASS(DeleteDC, HDC, NULL, AutoDeleteDC)
    AUTO_CLEANUP_CLASS(DeleteObject, HBITMAP, NULL, AutoDeleteObject)
    AUTO_CLEANUP_CLASS(GdipDisposeImage, GpBitmap*, NULL, AutoGdipDisposeImage)
    
    //
    // AutoReleaseDC
    //
    
    struct AutoReleaseDC : public AutoCleanup<HDC, NULL> {
 
        AutoReleaseDC(HDC hDC = NULL, HWND hWnd = NULL) 
        : 
        AutoCleanup(hDC), m_hWnd(hWnd) {}
 
        ~AutoReleaseDC()
        {
            if (true == IsValid()) {
                ::ReleaseDC(m_hWnd, m_Res);
            }
        }
 
        HDC operator=(HDC Res)
        { 
            return AutoCleanup::operator=(Res);  
        }
 
    private:
 
        const HWND m_hWnd;
    };
 
}; // namespace Auto
 
    ...

int main(int argc, char *argv[]) {
  ...
}

int main(int argc, char * argv[]) {
   std:vector<std::string> args(argv, argv + argc);
   ...
}

...
   std::cout <<  args[0] << std::endl;
...