Am I implementing the rule of five correctly? - c++

Question

I tried to read up on the topic of the Rule of 3/5/0 in C++, mainly from these posts:
What is The Rule of Three?
What is the copy-and-swap idiom?
Reading is good and all, but I tried to create a minimal example for myself, and I'm not sure if I did it correctly, or accidentally overlooked something.
Let's say, for a starting point, I have a class that manages a dynamically allocated C-style array, which looks like this:
Array.h
#pragma once
#include <cstddef>
#include <ostream>
class Array
{
private:
size_t _size;
int* _arr;
void checkRange(const size_t& index) const;
public:
Array(size_t size);
int getValue(size_t index) const;
void setValue(size_t index, int value);
size_t getSize() const;
//Copy semantics
Array(const Array& other) = delete;
void operator=(const Array& other) = delete;
//Move semantics
Array(Array&& other) = delete;
void operator=(Array&& other) = delete;
~Array();
};
std::ostream& operator<<(std::ostream& out, const Array& array);
Array.cpp
#include "Array.h"
#include <cstddef>
#include <stdexcept>
#include <string>
#include <ostream>
void Array::checkRange(const size_t& index) const
{
if(index > (_size - 1))
{
std::string message{
"tried to read from array at index "
+ std::to_string(index)
+ " but maximum possible index is "
+ std::to_string(_size - 1)
};
throw std::out_of_range(message);
}
}
Array::Array(size_t size)
: _size{size}, _arr{nullptr}
{
if(size < 1)
{
return;
}
_arr = new int[size]{};
}
int Array::getValue(size_t index) const
{
checkRange(index);
return _arr[index];
}
void Array::setValue(size_t index, int value)
{
checkRange(index);
_arr[index] = value;
}
size_t Array::getSize() const
{
return _size;
}
Array::~Array()
{
delete[] _arr;
_arr = nullptr;
}
std::ostream& operator<<(std::ostream& out, const Array& array)
{
size_t arraySize{array.getSize()};
for(size_t i{0}; i < arraySize; i++)
{
out << array.getValue(i) << ", ";
}
return out;
}
main.cpp
#include "Array.h"
#include <iostream>
int main()
{
Array array1(10);
array1.setValue(3, 42);
array1.setValue(7, 43);
std::cout << array1 << std::endl;
}
I wrote this class to the best of my current C++ knowledge, if there is anything wrong here, please let me know.
Copy and move semantics are explicitly hidden from this class, but now I tried to apply the concepts from the posts I read that I linked above.
I tried to incorporate the copy-and-swap idiom to move semantics as well, because the following tutorial:
Learn C++: M.3 — Move constructors and move assignment
suggests that the copy-and-swap idiom can be applied to move semantics as well.
Now, after bringing it all together, my code looks like this:
Array.h
#pragma once
#include <cstddef>
#include <ostream>
class Array
{
private:
size_t _size;
int* _arr;
void checkRange(const size_t& index) const;
public:
Array(size_t size);
int getValue(size_t index) const;
void setValue(size_t index, int value);
size_t getSize() const;
//Copy semantics
Array(const Array& other);
void operator=(Array other);
//Move semantics
Array(Array&& other);
void operator=(Array&& other);
//Needed for copy-swap idiom
friend void swap(Array& first, Array& second) noexcept;
~Array();
};
std::ostream& operator<<(std::ostream& out, const Array& array);
Array.cpp
#include "Array.h"
#include <cstddef>
#include <stdexcept>
#include <string>
#include <cstring>
#include <ostream>
#include <algorithm>
void Array::checkRange(const size_t& index) const
{
if(index > (_size - 1))
{
std::string message{
"tried to read from array at index "
+ std::to_string(index)
+ " but maximum possible index is "
+ std::to_string(_size - 1)
};
throw std::out_of_range(message);
}
}
Array::Array(size_t size)
: _size{size}, _arr{nullptr}
{
if(_size < 1)
{
return;
}
_arr = new int[size]{};
}
int Array::getValue(size_t index) const
{
checkRange(index);
return _arr[index];
}
void Array::setValue(size_t index, int value)
{
checkRange(index);
_arr[index] = value;
}
size_t Array::getSize() const
{
return _size;
}
//Copy semantics
Array::Array(const Array& other)
: _size{other._size}, _arr{nullptr}
{
if(_size < 1)
{
return;
}
//Make a deep copy of the C-style array
_arr = new int[_size]{};
std::memcpy(_arr, other._arr, sizeof(int) * _size);
}
//Applying copy-swap idiom: other object is passed by value!
void Array::operator=(Array other)
{
swap(*this, other);
}
//Move semantics
Array::Array(Array&& other)
{
//Copy and swap idiom works here too
//We don't have to deallocate our resources because after we "steal" its resources,
//the other object (which is an r-value) will do that automatically
//when it goes out of scope
swap(*this, other);
}
void Array::operator=(Array&& other)
{
//same as above
swap(*this, other);
}
Array::~Array()
{
delete[] _arr;
_arr = nullptr;
}
void swap(Array& first, Array& second) noexcept
{
std::swap(first._arr, second._arr);
std::swap(first._size, second._size);
}
std::ostream& operator<<(std::ostream& out, const Array& array)
{
size_t arraySize{array.getSize()};
for(size_t i{0}; i < arraySize; i++)
{
out << array.getValue(i) << ", ";
}
return out;
}
Did I implement the concepts of the Rule of 5 correctly? Is there anything else that could be wrong here?