Is there a safe way to iterate over std::unique_ptr<int[]>? - c++

Question

In the following code I get a warning with MSVC (C4996) that std::copy(errors.begin(),errors.end(),pErrors.get()); is not safe. It writes into the raw pointer. Is there an elegant and safe way to iterate over the elements?
The main goal is to prepare a built-in array for a call to a legacy function:
#include <iostream>
#include <initializer_list>
#include <memory>
#include <algorithm>
void print_errors_old_function(int argument_count,int* pErrors)
{
for (int i=0;i<argument_count;++i) { std::cerr << "Error" << pErrors[i] << " "; }
}
void print_errors(std::initializer_list<int> errors)
{
std::unique_ptr<int[]> pErrors{new int[errors.size()]};
std::copy(errors.begin(),errors.end(),pErrors.get()); // warning C4996
print_errors_old_function(errors.size(),pErrors.get());
}
int main()
{
print_errors({234,253,334});
return 0;
}
It seems a range based for loop is not possible with std::unique_ptr<int[]> and that regular for loop would arguably less readable than std::copy.

Answer 1

You don't need std::unique_ptr. std::vector will work fine, because &v[0] is guaranteed to give you a pointer to the internal buffer, and of course it also has a size() member function you can use to interface with C functions. Since C++11, there's also data(), which looks nicer than &v[0].
#include <iostream>
#include <initializer_list>
#include <vector>
void print_errors_old_function(int argument_count,int* pErrors)
{
for (int i=0;i<argument_count;++i) { std::cerr << "Error" << pErrors[i] << " "; }
}
void print_errors(std::initializer_list<int> errors)
{
std::vector<int> vErrors(errors);
print_errors_old_function(vErrors.size(), &vErrors[0] /* or vErrors.data() in C+11 */ );
}
int main()
{
print_errors({234,253,334});
return 0;
}
Notice how is also gets rid of the warning.

Answer 2

The other answer is correct, but note that were the function like this:
void print_errors_old_function(int argument_count,int* pErrors)
{
for (int i=0;i<argument_count;++i) { std::cerr << "Error" << pErrors[i] << " "; }
delete[] pErrors; // note this function effectively "consumes" the input
}
you wouldn't be able to use this approach, as there is no way to release ownership of the vector's memory. You'd have to make use std::unique_ptr the way you do in your question, but you'd have to use pErrors.release() instead of pErrors.get().
Visual C++ complains because on several functions which are defined in the standard, but it deems them as "unsafe", which makes standard-conforming code non-compilable. Sometimes, Microsoft provides workarounds, which are only available on Visual C++.
What you can do (choose one of these):
make use of the suggested Microsoft's workarounds
disable SDL checks (these checks turn these warnings into errors)
define _SCL_SECURE_NO_WARNINGS in your project. (to disable these warnings)