Smart replacement for 'new[]' to make_unique - c++

Question

I am in process of replacing statements like:
auto pszOutBuffer = new char[dwSize];
ReadDataFromHttp(pszOutBuffer, dwSize);
if(dwSize>100)
ParseHttpData(pszOutBuffer);
...
delete []pszOutBuffer;
TO:
auto OutBufferPtr = make_unique<char[]>(dwSize);
auto pszOutBuffer = OutBufferPtr.get();
ReadDataFromHttp(pszOutBuffer, dwSize);
if(dwSize>100)
ParseHttpData(pszOutBuffer);
...
So that I get advantage of smart pointer unique_ptr. I would like to keep the variable pszOutBuffer as is so less changes in Git commits appear, and unique_ptr.get() isn't required to be repeated.
To make this simple, and less verbose to read; I thought of writing a macro MAKE_UNIQUE_PTR(type,size) which will be a single statement (not two as shown above). But such macro will not be able to have unqiue_ptr as well as pszOutBuffer as in:
auto pszOutBuffer = MAKE_UNIQUE_PTR(char, dwSize);
I may think of writing a function template, but then... how to keep unique_ptr after function (MAKE_UNIQUE_PTR) returns?
EDIT:
With this hypothetical macro/function, the code would simply be:
auto pszOutBuffer = MAKE_UNIQUE_PTR(char, dwSize);
ReadDataFromHttp(pszOutBuffer, dwSize);
if(dwSize>100)
ParseHttpData(pszOutBuffer);
...
With these advantages:
unique_ptr still controls the life time of buffer.
Raw-style pointer is still in place without chaging them to unique_ptr::get() calls.
Hence can safely delete delete[] calls from multiple code paths.
NOTE that the very first code is the code I've in hand. No macro, no unique_ptr- just legacy code having new and delete. And yeah... those Hungarian notation variables.

Answer 1

Unfortunately, std::make_unique<T[N]>() is not supported for reasons you can see in the original proposal. However, nothing stops you from crafting your own make_unique for arrays (e.g., make_unique_array) as below:
template<typename T>
std::enable_if_t<std::is_array<T>::value, std::unique_ptr<T>>
make_unique_array(std::size_t const n) {
using RT = std::remove_extent_t<T>;
return std::unique_ptr<T>(new RT[n]);
}

Answer 2

As you are already using macro you can write one which creates both. It's ugly but does its job.
#define SmartMacro(pszOutBuffer, dwSize) \
auto pszOutBuffer##ptr = make_unique<char[]>(dwSize); \
auto pszOutBuffer = pszOutBuffer##ptr.get(); \
memset(pszOutBuffer, 0, dwSize);
// Usage
SmartMacro(buffer, 10);
// 'buffer' is the raw pointer
// 'bufferptr' is the unique pointer

Answer 3

template<class T, class D>
struct smart_unique:std::unique_ptr<T,D> {
using std::unique_ptr<T,D>::unique_ptr;
operator T*()const{return this->get();}
operator T const*()const{return this->get();}
};
template<class T, class D>
struct make_smart_unique_t {
template<class...Ts>
smart_unique<T, D> operator()(Ts&&...ts)const{
return smart_unique<T,D>( new T(std::forward<Ts>(ts)...); );
}
template<class T0, class...Ts>
smart_unique<T, D> operator()(std::initializer_list<T0> il, Ts&&...ts)const{
return smart_unique<T,D>( new T(il, std::forward<Ts>(ts)...); );
}
};
template<class T, class D>
struct make_smart_unique_t<T[], D> {
smart_unique<T[], D> operator[](std::size_t N)const{
return smart_unique<T[],D>( new T[N]; );
}
template<class...Ts>
smart_unique<T[], D> operator()(Ts&&...ts)const{
return smart_unique<T[],D>( new T[sizeof...(Ts)]{std::forward<Ts>(ts)...}; );
}
};
template<class T, class D=std::default_delete<T>>
constexpr make_smart_unique_t<T,D> make_smart_unique{};
this should support:
auto pszOutBuffer = make_smart_unique<char[]>[dwSize];
ReadDataFromHttp(pszOutBuffer, dwSize);
if(dwSize>100)
ParseHttpData(pszOutBuffer);
as well as:
auto pszDataBuffer = make_smart_unique<int[]>(1,2,3,4,5);
and
auto pszDataBuffer = make_smart_unique<int>();
no macro magic needed.
The design here is simple: make_smart_unique<scalar> is similar to make_unique, but it returns a smart_unique instead (which implicitly casts to T*: be very careful!)
make_smart_unique<Array[]> has two different ways to invoke it. With [N] is creates an array of the passed in size: with (args...) it creates an array of the size of the number of elements, and constructs each one from each arg.