Simplify std::copy with std::copy_n

+ a surprise `std::memcpy` in VolumeVerifier.cpp.

Source/Core/DiscIO/Blob.cpp

@@ -153,8 +153,7 @@ bool SectorReader::Read(u64 offset, u64 size, u8* out_ptr)
     u32 can_read = m_block_size * cache->num_blocks - read_offset;
     u32 was_read = static_cast<u32>(std::min<u64>(can_read, remain));
 
-    std::copy(cache->data.begin() + read_offset, cache->data.begin() + read_offset + was_read,
-              out_ptr);
+    std::copy_n(cache->data.begin() + read_offset, was_read, out_ptr);
 
     offset += was_read;
     out_ptr += was_read;

Source/Core/DiscIO/CompressedBlob.cpp

@@ -130,7 +130,7 @@ bool CompressedBlobReader::GetBlock(u64 block_num, u8* out_ptr)
 
   if (uncompressed)
   {
-    std::copy(m_zlib_buffer.begin(), m_zlib_buffer.begin() + comp_block_size, out_ptr);
+    std::copy_n(m_zlib_buffer.begin(), comp_block_size, out_ptr);
   }
   else
   {

Source/Core/DiscIO/DirectoryBlob.cpp

@@ -107,8 +107,7 @@ bool DiscContent::Read(u64* offset, u64* length, u8** buffer, DirectoryBlobReade
     else if (std::holds_alternative<ContentMemory>(m_content_source))
     {
       const auto& content = std::get<ContentMemory>(m_content_source);
-      std::copy(content->begin() + offset_in_content,
-                content->begin() + offset_in_content + bytes_to_read, *buffer);
+      std::copy_n(content->begin() + offset_in_content, bytes_to_read, *buffer);
     }
     else if (std::holds_alternative<ContentPartition>(m_content_source))
     {

Source/Core/DiscIO/LaggedFibonacciGenerator.cpp

@@ -78,8 +78,8 @@ bool LaggedFibonacciGenerator::GetSeed(const u32* data, size_t size, size_t data
   const size_t data_offset_mod_k = data_offset % LFG_K;
   const size_t data_offset_div_k = data_offset / LFG_K;
 
-  std::copy(data, data + LFG_K - data_offset_mod_k, lfg->m_buffer.data() + data_offset_mod_k);
-  std::copy(data + LFG_K - data_offset_mod_k, data + LFG_K, lfg->m_buffer.data());
+  std::copy_n(data, LFG_K - data_offset_mod_k, lfg->m_buffer.data() + data_offset_mod_k);
+  std::copy_n(data + LFG_K - data_offset_mod_k, data_offset_mod_k, lfg->m_buffer.data());
 
   lfg->Backward(0, data_offset_mod_k);
 

Source/Core/DiscIO/TGCBlob.cpp

@@ -28,8 +28,8 @@ void Replace(u64 offset, u64 size, u8* out_ptr, u64 replace_offset, u64 replace_
 
   if (replace_end > replace_start)
   {
-    std::copy(replace_ptr + (replace_start - replace_offset),
-              replace_ptr + (replace_end - replace_offset), out_ptr + (replace_start - offset));
+    std::copy_n(replace_ptr + (replace_start - replace_offset), replace_end - replace_start,
+                out_ptr + (replace_start - offset));
   }
 }
 

Source/Core/DiscIO/VolumeVerifier.cpp

@@ -1301,8 +1301,7 @@ void VolumeVerifier::Finish()
     {
       m_result.hashes.crc32 = std::vector<u8>(4);
       const u32 crc32_be = Common::swap32(m_crc32_context);
-      const u8* crc32_be_ptr = reinterpret_cast<const u8*>(&crc32_be);
-      std::copy(crc32_be_ptr, crc32_be_ptr + 4, m_result.hashes.crc32.begin());
+      std::memcpy(m_result.hashes.crc32.data(), &crc32_be, 4);
     }
 
     if (m_hashes_to_calculate.md5)

Source/Core/DiscIO/WIABlob.cpp

@@ -1635,7 +1635,7 @@ WIARVZFileReader<RVZ>::ProcessAndCompress(CompressThreadState* state, CompressPa
       const size_t size = state->compressor->GetSize();
 
       entry.main_data.resize(size);
-      std::copy(data, data + size, entry.main_data.data());
+      std::copy_n(data, size, entry.main_data.data());
 
       if (compressed_exception_lists)
         entry.exception_lists.clear();