// Copyright (c) 2020 by Chrono

//

// g++ container.cpp -std=c++11 -o a.out;./a.out

// g++ container.cpp -std=c++14 -o a.out;./a.out

// g++ container.cpp -std=c++14 -I../common -o a.out;./a.out

#include <cassert>

#include <iostream>

#include <complex>

#include <array>

#include <vector>

#include <deque>

#include <list>

#include <forward_list>

#include <set>

#include <map>

#include <unordered_set>

#include <unordered_map>

using namespace std;

class Point final

{

//private:

public:

int x = 0;

public:

Point(int a) noexcept : x(a)

{

cout << "ctor" << x << endl;

}

Point() noexcept

{

cout << "ctor" << x << endl;

}

~Point() noexcept

{

cout << "dtor" << x << endl;

}

Point(const Point& p) noexcept

{

x = p.x;

cout << "copy ctor"<< x << endl;

}

Point(Point&& p) noexcept

{

x = std::move(p.x);

cout << "move ctor" << x << endl;

}

};

void case1()

{

vector<Point> v;

v.reserve(10);

Point p;

v.push_back(p);

v.push_back(std::move(p));

v.emplace_back(1);

}

void case2()

{

array<int, 2> arr;

assert(arr.size() == 2);

vector<int> v(2);

for(int i = 0; i < 10; i++) {

v.emplace_back(i);

}

//cout << v.size() << endl;

assert(v.size() == 12);

deque<int> d;

d.emplace_back(9);

d.emplace_front(1);

assert(d.size() == 2);

}

bool operator<(const Point& a, const Point& b)

{

return a.x < b.x;

}

void case3()

{

set<Point> s;

s.emplace(7);

s.emplace(3);

for(auto& p : s) {

cout << p.x << ",";

}

cout << endl;

}

#if 0

using complex_t = complex<double>;

// add < compare to complex

namespace std{

bool operator<(const complex_t& a, const complex_t& b)

{

return a.real() < b.real();

}

}

void case3()

{

set<complex_t> s;

s.emplace(3, 1);

s.emplace(1, 1);

for(auto& c : s) {

cout << c << ",";

}

cout << endl;

}

#endif

void case4()

{

set<int> s = {7, 3, 9};

for(auto& x : s) {

cout << x << ",";

}

cout << endl;

auto comp = [](auto a, auto b)

{

return a > b;

};

set<int, decltype(comp)> gs(comp);

std::copy(begin(s), end(s),

inserter(gs, gs.end()));

for(auto& x : gs) {

cout << x << ",";

}

cout << endl;

}

void case5()

{

using map_type =

unordered_map<int, string>;

map_type dict;

dict[1] = "one";

dict.emplace(2, "two");

dict[10] = "ten";

for(auto& x : dict) {

cout << x.first << "=>"

<< x.second << ",";

}

cout << endl;

}

bool operator==(const Point& a, const Point& b)

{

return a.x == b.x;

}

void case6()

{

auto hasher = [](const auto& p)

{

return std::hash<int>()(p.x);

};

unordered_set<Point, decltype(hasher)> s(10, hasher);

s.emplace(7);

s.emplace(3);

for(auto& p : s) {

cout << p.x << ",";

}

cout << endl;

}

int main()

{

case1();

case2();

case3();

case4();

case5();

case6();

cout << "containter demo" << endl;

}