C++17 入门经典第17章学习笔记

这章的代码

#include <iostream>
#include <vector>
#include <algorithm>
#include <stdexcept>
using namespace std;

template <typename T>
class Array
{
private:
	T* elements;
	size_t size;

public:
	explicit Array(size_t arraySize = 0);
	Array(const Array& moved);
	Array(Array&& array) noexcept;
	~Array();
	Array& operator=(const Array& rhs);
	Array& operator=(Array&& rhs) noexcept;

	T& operator[](size_t index);
	const T& operator[](size_t index) const;
	size_t getSize() const noexcept { return size; }
	void swap(Array& other) noexcept;

	void push_back(T element);
};

Array<std::string> buildStringArray(const size_t size)
{
	Array<std::string> result{ size };
	for (size_t i=0; i<size; ++i)
	{
		result[i] = "You should learn from your competitor, but newer copy, Copy and you die.";
	}
	return result;
}

Array<std::string> buildStringArray(Array<std::string> &out)
{
	return out;
}

template<typename T>
Array<T>::Array(size_t arraySize) : elements{ new T[arraySize] }, size(arraySize)
{}

template<typename T>
Array<T>::Array(const Array & array) : Array{array.size}
{
	std::cout << "Array of " << size << " elements copied" << std::endl;
	for (size_t i{}; i<size; ++i)
	{
		elements[i] = array.elements[i];
	}
}

template<typename T>
Array<T>::Array(Array && moved) noexcept : size{ moved.size }, elements{ moved.elements }
{
	std::cout << "Array of " << size << " elements moved" << std::endl;
	moved.elements = nullptr;
}

template<typename T>
Array<T>::~Array()
{
	delete[] elements;
}

template<typename T>
Array<T>& Array<T>::operator=(const Array& rhs)
{
	// TODO: 在此处插入 return 语句
	Array<T> copy(rhs);
	swap(copy);
	return *this;
}

template<typename T>
Array<T> & Array<T>::operator=(Array && rhs) noexcept
{
	// TODO: 在此处插入 return 语句
	std::cout << "Array of " << rhs.size << " element moved (assignment)" << std::endl;

	Array<T> moved(std::move(rhs));
	swap(moved);

	return *this;
}

template<typename T>
T& Array<T>::operator[](size_t index)
{
	// TODO: 在此处插入 return 语句
	if (index >= size)
	{
		throw std::out_of_range{ "Index too large: "};
	}
	return elements[index];
}

template<typename T>
const T & Array<T>::operator[](size_t index) const
{
	// TODO: 在此处插入 return 语句
	if (index >= size)
	{
		throw std::out_of_range{ "Index too large: " + std::to_string(index) };
	}
	return elements[index];
}

template<typename T>
void Array<T>::swap(Array & other) noexcept
{
	std::swap(elements, other.elements);
	std::swap(size, other.size);
}

template<typename T>
void Array<T>::push_back(T element)
{
	Array<T> newArray(size + 1);
	for (size_t i = 0; i<size; ++i)
	{
		newArray[i] = std::move(elements[i]);
	}
	newArray[size] = std::move(element);

	swap(newArray);
}

int main()
{
	std::vector<Array<std::string>> v;
	v.push_back(buildStringArray(1000));
	std::cout << std::endl;
	v.push_back(buildStringArray(2000));

	//Array<Array<std::string>> array_of_arrays;
	//Array<std::string> array{ buildStringArray(1000) };
	//array_of_arrays.push_back(array);

	//array.push_back("One more for good measure");
	//std::cout << std::endl;
	//array_of_arrays.push_back(std::move(array));

	//Array<std::string> strings{ 123 };
	//strings = buildStringArray(1000);

	//Array<std::string> more_strings{ 2000 };
	//Array<std::string>&& rvalue_ref{ std::move(more_strings) };
	//strings = std::move(rvalue_ref);
	//strings = std::move(more_strings);

	//const size_t numArrays{ 10 };
	//const size_t numStringsPerArray{ 1000 };
	//std::vector<Array<std::string>> vectorOfArrays;

	Array<std::string> string_array(numStringsPerArray);
	buildStringArray(string_array);
	vectorOfArrays.push_back(string_array);

	//vectorOfArrays.reserve(numArrays);

	//for (size_t i = 0; i<numArrays; ++i)
	//{
	//	vectorOfArrays.push_back(buildStringArray(numStringsPerArray));
	//}
	return 0;
}