std::copy with a std::shared_ptr - c++

Question

#include <iostream>
struct Data
{
std::shared_ptr<char[]> m_name = nullptr; // char* m_name = nullptr;
// bool m_owner = false;
Data() = default;
Data(const char* name)
{
using std::copy;
int size = strlen(name) + 1;
m_name = std::make_unique<char[]>(size); // m_name = new char[size];
copy(name, name + size, m_name.get());
// m_owner = true;
}
// ~Data()
// {
// if (/*m_name &&*/ m_owner)
// delete[] m_name;
// m_name = nullptr;
// }
void print()
{
using std::cout, std::endl;
if (!m_name)
return;
int size = strlen(m_name.get());
for(int i = 0; i < size; ++i)
cout << m_name[i];
cout << endl;
}
};
void shallow_copy(Data& dst, Data& src)
{
dst.m_name = src.m_name;
}
void deep_copy(Data& dst, Data& src)
{
using std::copy;
int size = strlen(src.m_name.get())+1;
dst.m_name = std::make_unique<char[]>(size); // dst.m_name = new char[size];
copy(src.m_name.get(), src.m_name.get() + size, dst.m_name.get());
// dst.m_owner = true;
}
int main()
{
using std::cout, std::endl;
cout << "starting..." << endl;
auto data1 = new Data{"abc"};
data1->print();
auto data2 = new Data();
data2->print();
// shallow_copy(*data2, *data1);
deep_copy(*data2, *data1);
// delete data1;
data2->print();
}
While trying to replace char* by std::shared_ptr<char[]> above, I noticed things get a little more verbose with copy, going from
copy(src.m_name, src.m_name + size, dst.m_name);
to
copy(src.m_name.get(), src.m_name.get() + size, dst.m_name.get());
Is there a better (shorter) way than typing that .get() every time?

Answer 1

Is there a better (shorter) way than typing that .get() every time?
Not when using smart pointers, no. Best you can do is call .get() earlier and save the pointer for reuse, eg:
char *ptr = src.m_name.get();
copy(ptr, ptr + size, dst.m_name.get());
Alternatively, in this particular example, you can use std::copy_n() instead of std::copy(), eg:
copy_n(src.m_name.get(), size, dst.m_name.get());

Answer 2

If you know the std::shared/unique_ptr<char[]> won't go out of scope immediately, you can grab a the underlying pointer beforehand and use that. It makes the lines where you use the address look a little neater at the cost of an extra line or two. I personally think it's worth the cost.
const char* const src_ptr = src.m_name.get();
char* const dst_ptr = dst.m_name.get();
// assume m_name for either stays in scope until the next line completes
std::copy(src_ptr, src_ptr + size, dst_ptr);