c++_primer_exercise_1339

/***********************************************
 * IDE:  VS2010
 * FILE: Str_vec.h
 ***********************************************/
#ifndef STR_VEC_H
#define STR_VEC_H

#include 
#include 	// for allocator
#include 	// for pair

class Str_vec
{
public:
	// copy control members
	Str_vec() :		// the allocator member is default initialized
	  elements(nullptr), first_free(nullptr), cap(nullptr) { }
	Str_vec(const std::string *b, const std::string *e);

	Str_vec(const Str_vec &);				// copy constructor
	Str_vec &operator=(const Str_vec &rhs);	// copy assignment
	~Str_vec() { free(); }							// destructor

	void push_back(const std::string &);	// copy the element
	
	// add elements
	size_t size() const { return first_free - elements; }  //typedef unsigned int size_t
	size_t capacity() const { return cap - elements; }

	// iterator interface
	std::string *begin() const { return elements; }
	std::string *end() const { return first_free; }

	std::string & operator[](std::size_t n)
	{ return elements[n]; }

private:
	static std::allocator alloc;	// allocates the elements
	std::string *elements;	// pointer to the first element in the array
	std::string *first_free;// pointer to the first free element in the array
	std::string *cap;		// pointer to one past the end of the array
	
	// utility functions:
	// used by members that add elements to the Str_vec
	void chk_n_alloc()
		{ if (size() == capacity()) reallocate(); }
	// used by the copy constructor, assignment operator, and destructor
	std::pair alloc_n_copy
		(const std::string *, const std::string *);
	void free();			// destroy the elements and free the space
	void reallocate();		// get more space and copy the existing elements
};

#endif

/***********************************************
 * IDE:  VS2010
 * FILE: Str_vec.cpp
 ***********************************************/
#include 
using std::string;

#include 	// for uninitialized_copy
using std::allocator; using std::uninitialized_copy;

#include 	// for move
using std::pair; 

#include "Str_vec.h"

// utility function
void Str_vec::push_back(const string &s)
{
	chk_n_alloc();	// ensure that there is room for another element
	// construct a copy of s in the element to which first_free points
	alloc.construct(first_free++, s);
}

// the first member of the returned pair points to the
// start of the allocated memory;
// the second is pointer positioned one element past the
// last constructed element.
pair 
Str_vec::alloc_n_copy(const string *b, const string *e)
{
	// allocate space to hold as many elements as are in the range
	string *data = alloc.allocate(e - b);
	
	// initialize and return a pair constructed from data and
	// the value returned by uninitialized_copy
	return make_pair(data, uninitialized_copy(b, e, data));
}

Str_vec::Str_vec(const std::string *b, const std::string *e)
{
	// copy alloc_n_copy to allocate exactly as many elements as in the range
	pair newdata = alloc_n_copy(b, e);
	elements = newdata.first;
	first_free = cap = newdata.second;
}

// destroy the element, and then deallocate the space 
// that this Str_vec itself allocated
void Str_vec::free()
{
	// may not pass deallocate a 0 pointer; if element is 0,
	// there's no work to do
	if (elements)
	{
		for (string *p = first_free; p != elements; /* empyt */)
		{
			alloc.destroy(--p);
		}
		alloc.deallocate(elements, cap - elements);
	}
}

// copy constructor
Str_vec::Str_vec(const Str_vec &s)
{
	// call alloc_n_copy to allocate exactly as many elements as in s
	pair newdata = alloc_n_copy(s.begin(), s.end());
	elements = newdata.first;
	first_free = cap = newdata.second;
}

// copy-assignment operator
Str_vec &Str_vec::operator=(const Str_vec &rhs)
{
	// call alloc_n_copy to allocate exactly as many elements in rhs
	pair data = alloc_n_copy(rhs.begin(), rhs.end());
	free();
	elements = data.first;
	first_free = cap = data.second;
	return *this;
}

void Str_vec::reallocate()
{
	// we'll allocate space for twice as many elements as the current size
	size_t newcapacity = size() ? 2 * size() : 1;
	// allocate new memory
	string *newdata = alloc.allocate(newcapacity);
	// move the data from the old memory to the new
	string *dest = newdata;	// points to the next free position in the new array
	string *elem = elements;// points to the next element in the old array
	for (size_t i = 0; i != size(); ++i)
	{
		alloc.construct(dest++, std::move(*elem++));
	}
	free();		// free the old space once we've moved the elements
	// update our data structure to point to the new elements
	elements = newdata;
	first_free = dest;
	cap = elements + newcapacity;
}

/***********************************************
 * IDE:  VS2010
 * FILE: use_Str_vec.cpp
 ***********************************************/
#include 
using std::string;

#include 
using std::begin; using std::end;

#include 
using std::allocator;

#include 
using std::cin; using std::cout; using std::endl;

#include "Str_vec.h"

void print(const Str_vec &svec)
{
	for (string *iter = svec.begin(); iter != svec.end(); ++iter)
	{
		cout << *iter << " ";
	}
	cout << endl;
}


allocator Str_vec::alloc;

int main(void)
{
	string temp[] = {"Alice", "two", "three"};
	Str_vec sv(begin(temp), end(temp));

	if (!sv[0].empty())
	{
		sv[0] = "one";
	}
	print(sv);		// print "None" "two" "three"

	cout << "1. copy " << sv.size() << endl;
	Str_vec svec = sv;
	print(svec);

	cout << "2. push_back " << "four" << " five" << endl;
	string s = "four";
	sv.push_back(s);
	sv.push_back("five");
	print(sv);

	cout << "3. assignment operator " << sv.size() << endl;
	Str_vec vec;	// empty Str_vec
	vec = sv;
	print(vec);

	return 0;
}