#include "allocator.hpp"
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
namespace allocator_ {
 
 
// reference: C++ Primer(Fifth Edition) 12.2.2
int test_allocator_1()
{
	std::allocator<std::string> alloc; // 可以分配string的allocator對象
	int n{ 5 };
	auto const p = alloc.allocate(n); // 分配n個未初始化的string
 
	auto q = p; // q指向最后構(gòu)造的元素之后的位置
	alloc.construct(q++); // *q為空字符串
	alloc.construct(q++, 10, 'c'); // *q為cccccccccc
	alloc.construct(q++, "hi"); // *q為hi
 
	std::cout << *p << std::endl; // 正確：使用string的輸出運算符
	//std::cout << *q << std::endl; // 災(zāi)難：q指向未構(gòu)造的內(nèi)存
	std::cout << p[0] << std::endl;
	std::cout << p[1] << std::endl;
	std::cout << p[2] << std::endl;
 
	while (q != p) {
		alloc.destroy(--q); // 釋放我們真正構(gòu)造的string
	}
 
	alloc.deallocate(p, n);
 
	return 0;
}
 
int test_allocator_2()
{
	std::vector<int> vi{ 1, 2, 3, 4, 5 };
 
	// 分配比vi中元素所占用空間大一倍的動態(tài)內(nèi)存
	std::allocator<int> alloc;
	auto p = alloc.allocate(vi.size() * 2);
	// 通過拷貝vi中的元素來構(gòu)造從p開始的元素
	/* 類似拷貝算法，uninitialized_copy接受三個迭代器參數(shù)。前兩個表示輸入序列，第三個表示
	這些元素將要拷貝到的目的空間。傳遞給uninitialized_copy的目的位置迭代器必須指向未構(gòu)造的
	內(nèi)存。與copy不同，uninitialized_copy在給定目的位置構(gòu)造元素。
	類似copy，uninitialized_copy返回(遞增后的)目的位置迭代器。因此，一次uninitialized_copy調(diào)用
	會返回一個指針，指向最后一個構(gòu)造的元素之后的位置。
	*/
	auto q = std::uninitialized_copy(vi.begin(), vi.end(), p);
	// 將剩余元素初始化為42
	std::uninitialized_fill_n(q, vi.size(), 42);
 
	return 0;
}
 
 
// reference: http://www.modernescpp.com/index.php/memory-management-with-std-allocator
int test_allocator_3()
{
	std::cout << std::endl;
 
	std::allocator<int> intAlloc;
 
	std::cout << "intAlloc.max_size(): " << intAlloc.max_size() << std::endl;
	int* intArray = intAlloc.allocate(100);
 
	std::cout << "intArray[4]: " << intArray[4] << std::endl;
 
	intArray[4] = 2011;
 
	std::cout << "intArray[4]: " << intArray[4] << std::endl;
 
	intAlloc.deallocate(intArray, 100);
 
	std::cout << std::endl;
 
	std::allocator<double> doubleAlloc;
	std::cout << "doubleAlloc.max_size(): " << doubleAlloc.max_size() << std::endl;
 
	std::cout << std::endl;
 
	std::allocator<std::string> stringAlloc;
	std::cout << "stringAlloc.max_size(): " << stringAlloc.max_size() << std::endl;
 
	std::string* myString = stringAlloc.allocate(3);
 
	stringAlloc.construct(myString, "Hello");
	stringAlloc.construct(myString + 1, "World");
	stringAlloc.construct(myString + 2, "!");
 
	std::cout << myString[0] << " " << myString[1] << " " << myString[2] << std::endl;
 
	stringAlloc.destroy(myString);
	stringAlloc.destroy(myString + 1);
	stringAlloc.destroy(myString + 2);
	stringAlloc.deallocate(myString, 3);
 
	std::cout << std::endl;
 
	return 0;
}
 
//
// reference: http://en.cppreference.com/w/cpp/memory/allocator
int test_allocator_4()
{
	std::allocator<int> a1;   // default allocator for ints
	int* a = a1.allocate(1);  // space for one int
	a1.construct(a, 7);       // construct the int
	std::cout << a[0] << '\n';
	a1.deallocate(a, 1);      // deallocate space for one int
 
	// default allocator for strings
	std::allocator<std::string> a2;
 
	// same, but obtained by rebinding from the type of a1
	decltype(a1)::rebind<std::string>::other a2_1;
 
	// same, but obtained by rebinding from the type of a1 via allocator_traits
	std::allocator_traits<decltype(a1)>::rebind_alloc<std::string> a2_2;
 
	std::string* s = a2.allocate(2); // space for 2 strings
 
	a2.construct(s, "foo");
	a2.construct(s + 1, "bar");
 
	std::cout << s[0] << ' ' << s[1] << '\n';
 
	a2.destroy(s);
	a2.destroy(s + 1);
	a2.deallocate(s, 2);
 
	return 0;
}
 
} // namespace allocator_