struct Vec4
{
    float v[4];
}

void Update()
{
    Sleep(300);
    static int = 0;
    std::vector<Vec4> pixels(canvasWidth * canvasHeight, Vec4{1.0f, 1.0f, 1.0f, 1.0f});
    pixels[i] = Vec4{ 1.0f, 0.0f, 0.0f, 1.0f };
    if (i >= pixels.size() - 1)
    {
        i = 0;
    }
    else
    {
        i++;
    }

    // Update Texture Buffer
    D3D11_MAPPED_SUBRESOURCE ms;
	deviceContext->Map(canvasTexture, NULL, D3D11_MAP_WRITE_DISCARD, NULL, &ms);
	memcpy(ms.pData, pixels.data(), pixels.size() * sizeof(Vec4));
	deviceContext->Unmap(canvasTexture, NULL);
}

#define STB_IMAGE_IMPLEMENTATION
#include <stb_image.h>
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include <stb_image_write.h>
#include <algorithm> // std::clmap(c++ 17)
class Image
{
public:
    int width = 0, height = 0, channels = 0;
    std::vector<Vec4> pixels; 

    void ReadFromFile(const char* fileName);
    void WritePNG(const char* filename);
    Vec4& GetPixel(int i, int j);
}

void Image::ReadFromFile(const char* fileName)
{
    // 대부분의 img 는 0 ~ 255 값을 가지고 있기때문에 unsigned char 로 저장
    unsigned char* img = stbi_load(fileName, &width, &height, &channels, 0);

    if (width) {
		std::cout << width << " " << height << " " << channels << std::endl;
	}
	else {
		std::cout << "Error: reading " << filename << " failed." << std::endl;
	}

    // channel 이 3 이나 4 일걸 가정
    pixels.resize(width * height);
    for(int i = 0; i < width * height; i++)
    {
        pixels[i].v[0] = img[i * channels] / 255.0f;
		pixels[i].v[1] = img[i * channels +1] / 255.0f;
		pixels[i].v[2] = img[i * channels +2] / 255.0f;
		pixels[i].v[3] = 1.0f;
    }

    delete [] img;
}

void Image::WritePNG(const char* filename)
{
	// 32bit -> 8bits
	std::vector<unsigned char> img(width * height * channels, 0);
	for (int i = 0; i < width * height; i++)
	{
		img[i * channels] = uint8_t(pixels[i].v[0] * 255.0f); 
		img[i * channels + 1] = uint8_t(pixels[i].v[1] * 255.0f);
		img[i * channels + 2] = uint8_t(pixels[i].v[2] * 255.0f);
	}

	stbi_write_png(filename, width, height, channels, img.data(), width * channels);
}

Vec4& Image::GetPixel(int i, int j)
{
	i = std::clamp(i, 0, this->width - 1);
	j = std::clamp(j, 0, this->height - 1);

	return this->pixels[i + this->width * j];
}

for (int j = 0; j < this->height; j++)
{
	for (int i = 0; i < this->width; i++)
	{
		Vec4 neighborColorSum{ 0.0f, 0.0f, 0.0f, 1.0f };
		for (int si = 0; si < 5; si++)
		{
			Vec4 neighborColor = this->GetPixel(i + si - 2, j);
			neighborColorSum.v[0] += neighborColor.v[0];
			neighborColorSum.v[1] += neighborColor.v[1];
			neighborColorSum.v[2] += neighborColor.v[2];
		}
		pixelsBuffer[i + this->width * j].v[0] = neighborColorSum.v[0] * 0.2f;
		pixelsBuffer[i + this->width * j].v[1] = neighborColorSum.v[1] * 0.2f;
		pixelsBuffer[i + this->width * j].v[2] = neighborColorSum.v[2] * 0.2f;
	}
}

for (int j = 0; j < this->height; j++)
{
	for (int i = 0; i < this->width; i++)
	{
		Vec4 neighborColorSum{ 0.0f, 0.0f, 0.0f, 1.0f };
		for (int si = 0; si < 5; si++)
		{
			Vec4 neighborColor = this->GetPixel(i, j + si - 2);
			neighborColorSum.v[0] += neighborColor.v[0];
			neighborColorSum.v[1] += neighborColor.v[1];
			neighborColorSum.v[2] += neighborColor.v[2];
		}
		pixelsBuffer[i + this->width * j].v[0] = neighborColorSum.v[0] * 0.2f;
		pixelsBuffer[i + this->width * j].v[1] = neighborColorSum.v[1] * 0.2f;
		pixelsBuffer[i + this->width * j].v[2] = neighborColorSum.v[2] * 0.2f;
	}
}

for (int i = 0; i < this->width; i++)
{
	Vec4 neighborColorSum{ 0.0f, 0.0f, 0.0f, 1.0f };
	for (int si = 0; si < 5; si++)
	{
		Vec4 neighborColor = this->GetPixel(i + si - 2 , j);
		neighborColorSum.v[0] += neighborColor.v[0] * weights[si];
		neighborColorSum.v[1] += neighborColor.v[1] * weights[si];
		neighborColorSum.v[2] += neighborColor.v[2] * weights[si];
    }
	pixelsBuffer[i + this->width * j].v[0] = neighborColorSum.v[0];
	pixelsBuffer[i + this->width * j].v[1] = neighborColorSum.v[1];
	pixelsBuffer[i + this->width * j].v[2] = neighborColorSum.v[2];
}

for (int j = 0; j < this->height; j++)
{
	for (int i = 0; i < this->width; i++)
	{
		// 주변 픽셀들의 색을 평균내어서 (i, j)에 있는 픽셀의 색을 변경
		// this->pixels로부터 읽어온 값들을 평균내어서 pixelsBuffer의 값들을 바꾸기
		Vec4 neighborColorSum{ 0.0f, 0.0f, 0.0f, 1.0f };
		for (int si = 0; si < 5; si++)
		{
			Vec4 neighborColor = this->GetPixel(i, j + si - 2);
			neighborColorSum.v[0] += neighborColor.v[0] * weights[si];
			neighborColorSum.v[1] += neighborColor.v[1] * weights[si];
			neighborColorSum.v[2] += neighborColor.v[2] * weights[si];
		}
		pixelsBuffer[i + this->width * j].v[0] = neighborColorSum.v[0];
		pixelsBuffer[i + this->width * j].v[1] = neighborColorSum.v[1];
		pixelsBuffer[i + this->width * j].v[2] = neighborColorSum.v[2];
	}
}

for (int j = 0; j < height; j ++)
	for (int i = 0; i < width; i++)
	{
		auto& c = this->GetPixel(i, j);
		const float relativeLuminance = c.v[0] * 0.2126 + c.v[1] * 0.7152 + c.v[2] * 0.0722;
		if (relativeLuminance < th)
		{
			c.v[0] = 0.0f;
			c.v[1] = 0.0f;
			c.v[2] = 0.0f;
		}
	}

for (int i = 0; i < pixelsBackup.size(); i++)
{
	this->pixels[i].v[0] = std::clamp(pixels[i].v[0] * weight + pixelsBackup[i].v[0], 0.0f, 1.0f);
	this->pixels[i].v[1] = std::clamp(pixels[i].v[1] * weight + pixelsBackup[i].v[1], 0.0f, 1.0f);
	this->pixels[i].v[2] = std::clamp(pixels[i].v[2] * weight + pixelsBackup[i].v[2], 0.0f, 1.0f);
}

int main()
{
    auto work_func = [](const string& name)
	{
		for (int i = 0; i < 5; ++i)
		{
			std::this_thread::sleep_for(std::chrono::milliseconds(100));
			cout << name << " " << std::this_thread::get_id() << " is working " << i << endl;
		}
	};

    std::thread t1 = std::thread(work_func, "Jack");
	std::thread t2 = std::thread(work_func, "Nick");

    t1.join();
	t2.join();
}

using namespace std;

mutex mtx; // mutual exclusion
int main()
{
	std::vector<float> myArr;
	myArr.resize(10);
	const int num_process = std::thread::hardware_concurrency(); // number of core
	auto work_func = [](const string& name, std::vector<float>& myArr)
		{
			for (int i = 0; i < 5; ++i)
			{
				std::this_thread::sleep_for(std::chrono::milliseconds(100));

				// Don't touch it
				mtx.lock();
				myArr.push_back(i);
				cout << name << " " << std::this_thread::get_id() << " is working " << i << endl;
				mtx.unlock();
			}
		};

    std::thread t1 = std::thread(work_func, "JackJack", std::ref(myArr));
	std::thread t2 = std::thread(work_func, "DashDash", std::ref(myArr));
	t1.join();
	t2.join();

	for (int i = 0; i < myArr.size(); i++)
	{
		cout << myArr[i] << endl;
	}
    return 0;
}

int main()
{

	int shared_memory(0);
	auto count_func = [&]()
		{
			for (int i = 0; i < 1000; ++i)
			{
				this_thread::sleep_for(chrono::microseconds(1));
				shared_memory++;
			}
		};

	std::thread t1 = thread(count_func);

	t1.join();

	cout << "After" << endl;
	cout << shared_memory << endl;

	return 0;
}

int main()
{

	int shared_memory(0);
	auto count_func = [&]()
		{
			for (int i = 0; i < 1000; ++i)
			{
				this_thread::sleep_for(chrono::microseconds(1));
				shared_memory++;
			}
		};

	std::thread t1 = thread(count_func);
	std::thread t2 = thread(count_func);

	t1.join();
	t2.join();

	cout << "After" << endl;
	cout << shared_memory << endl;

	return 0;
}

int main()
{
	std::atomic<int> shared_memory(0);
	auto count_func = [&]()
		{
			for (int i = 0; i < 1000; ++i)
			{
				this_thread::sleep_for(chrono::microseconds(1));
				shared_memory++; // shared_memory.fetch_add(1);
			}
		};

	std::thread t1 = thread(count_func);
	std::thread t2 = thread(count_func);

	t1.join();
	t2.join();

	cout << "After" << endl;
	cout << shared_memory << endl;

	return 0;
}

mutex mtx;
int main()
{
	std::atomic<int> shared_memory(0);
	auto count_func = [&]()
		{
			for (int i = 0; i < 1000; ++i)
			{
				std::lock_guard lock(mtx);
				shared_memory++; // shared_memory.fetch_add(1);
			}
		};

	std::thread t1 = thread(count_func);
	std::thread t2 = thread(count_func);

	t1.join();
	t2.join();

	cout << "After" << endl;
	cout << shared_memory << endl;

	return 0;
}

#include <iostream>
#include <future>
#include <thread>
int main()
{
	// Thread
	int result;
	std::thread t1([&] {result = 1 + 2; });
	t1.join(); 
	cout << result << endl;

	// Future [Async]
	auto fut = std::async([] { return 1 + 2; });
	cout << fut.get() << endl;
}

#include <iostream>
#include <future>
#include <thread>
int main()
{
	std::promise<int> prom;
	auto fut = prom.get_future();

	auto t = std::thread([](std::promise<int>&& prom)
			{
				prom.set_value(1 + 2);
			}, std::move(prom));

	cout << fut.get() << endl;
	t.join();
	return 0;
}

#include <iostream>
#include <future>
#include <thread>
int main()
{
	auto f1 = std::async([] {
			cout << "async1 start" << endl;
			this_thread::sleep_for(chrono::seconds(2));
			cout << "async1 end" << endl;
			});

		auto f2 = std::async([] {
			cout << "async2 start" << endl;
			this_thread::sleep_for(chrono::seconds(1));
			cout << "async2 end" << endl;
			});

		cout << "Main Function" << endl;
}

#include <iostream>
#include <chrono>
#include <mutex>
#include <random>
#include <utility>
#include <vector>
#include <atomic>
#include <numeric>   // std::inner_product
#include <execution> // Parallel Execution
#include <future>
#include <thread>

using namespace std;
mutex mtx;

void dotProductNaive(const vector<int>& v0, const vector<int>& v1, const unsigned i_start, const unsigned i_end, unsigned long long& sumOut)
{
	for (unsigned i = i_start; i < i_end; ++i)
	{
		sumOut += v0[i] * v1[i];
	}
}

void dotProductLock(const vector<int>& v0, const vector<int>& v1, const unsigned i_start, const unsigned i_end, unsigned long long& sumOut)
{
	for (unsigned i = i_start; i < i_end; ++i)
	{
		std::scoped_lock lock(mtx);
		sumOut += v0[i] * v1[i];
	}
}

void dotProductAtomic(const vector<int>& v0, const vector<int>& v1, const unsigned i_start, const unsigned i_end, atomic<unsigned long long>& sumOut)
{
	for (unsigned i = i_start; i < i_end; ++i)
	{
		sumOut += v0[i] * v1[i];
	}
}

auto dotProductFuture(const vector<int>& v0, const vector<int>& v1, const unsigned i_start, const unsigned i_end)
{
	int sum = 0;
	for (unsigned i = i_start; i < i_end; ++i)
	{
		sum += v0[i] * v1[i];
	}
	return sum;
}

int main()
{
	const long long n_data = 100'000'000;
	const unsigned n_threads = 4;

	std::vector<int> v0, v1;
	v0.reserve(n_data);
	v1.reserve(n_data);

	random_device seed;
	mt19937 engine(seed());

	uniform_int_distribution<> uniformDist(1, 10);
	for (long long i = 0; i < n_data; ++i)
	{
		v0.push_back(uniformDist(engine));
		v1.push_back(uniformDist(engine));
	}

	// inner product from c++ library
	{
		const auto sta = chrono::steady_clock::now();
		const auto sum = std::inner_product(v0.begin(), v0.end(), v1.begin(), 0ull);
		const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
		cout << dur.count() << endl;
		cout << sum << endl;
		cout << endl;
	}

	// Naive (Race Condition)
	{
		const auto sta = chrono::steady_clock::now();
		unsigned long long sum = 0;
		vector<thread> threads;
		threads.resize(n_threads);

		const unsigned n_per_thread = n_data / n_threads; // assumes the remainder = 0
		for (unsigned t = 0; t < n_threads; ++t)
		{
			threads[t] = std::thread(dotProductNaive, std::ref(v0), std::ref(v1), t * n_per_thread, (t + 1) * n_per_thread, std::ref(sum));
		}

		for (unsigned t = 0; t < n_threads; ++t)
		{
			threads[t].join();
		}
		const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
		cout << dur.count() << endl;
		cout << sum << endl;
		cout << endl;
	}

	// Lock Guard
	{
		const auto sta = chrono::steady_clock::now();
		unsigned long long sum = 0;
		vector<thread> threads;
		threads.resize(n_threads);

		const unsigned n_per_thread = n_data / n_threads; // assumes the remainder = 0
		for (unsigned t = 0; t < n_threads; ++t)
		{
			threads[t] = std::thread(dotProductLock, std::ref(v0), std::ref(v1), t * n_per_thread, (t + 1) * n_per_thread, std::ref(sum));
		}

		for (unsigned t = 0; t < n_threads; ++t)
		{
			threads[t].join();
		}
		const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
		cout << dur.count() << endl;
		cout << sum << endl;
		cout << endl;
	}

	// atomic
	{
		const auto sta = chrono::steady_clock::now();
		std::atomic<unsigned long long> sum = 0;
		vector<thread> threads;
		threads.resize(n_threads);

		const unsigned n_per_thread = n_data / n_threads; // assumes the remainder = 0
		for (unsigned t = 0; t < n_threads; ++t)
		{
			threads[t] = std::thread(dotProductAtomic, std::ref(v0), std::ref(v1), t * n_per_thread, (t + 1) * n_per_thread, std::ref(sum));
		}

		for (unsigned t = 0; t < n_threads; ++t)
		{
			threads[t].join();
		}
		const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
		cout << dur.count() << endl;
		cout << sum << endl;
		cout << endl;
	}

	// future
	{
		const auto sta = chrono::steady_clock::now();
		unsigned long long sum = 0;
		vector<std::future<int>> futures;
		futures.resize(n_threads);
		const unsigned n_per_thread = n_data / n_threads;
		for (unsigned t = 0; t < n_threads; ++t)
		{
			futures[t] = std::async(dotProductFuture, std::ref(v0), std::ref(v1), t * n_per_thread, (t + 1) * n_per_thread);
		}

		for (unsigned t = 0; t < n_threads; ++t)
		{
			futures[t].get();
		}
		const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
		cout << dur.count() << endl;
		cout << sum << endl;
		cout << endl;
	}

	// transform reduce
	{
		const auto sta = chrono::steady_clock::now();
		const auto sum = std::transform_reduce(std::execution::par, v0.begin(), v0.end(), v1.begin(), 0ull);
		const chrono::duration<double> dur = chrono::steady_clock::now() - sta;
		cout << dur.count() << endl;
		cout << sum << endl;
		cout << endl;
	}

	return 0;
}

#include <iostream>
using namespace std;

inline int min(int x, int y)
{
    return x > y ? y : x;
}

int main()
{
    cout << min(5, 6) << endl;
    cout << min(3, 2) << endl;

    cout << (5 > 6 ? 6 : 5) << endl;
    cout << (3 > 2 ? 2 : 3) << endl;
    return 0;
}

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

class Knight
{
public:
    Knight(){}
    Knight(int a, int b){} 
    Knight(initializer_list<int> li) // 초기화할때 리스트
    {
        cout << "Knight(Initialize List)" << endl;
    }
}

int main()
{
    int a = 10;
    int b{0};                   // int b(0);
    int c{0};                   // int c(0):

    Knight k1;
    Knight k2 = k1              // 복사 생성자 (대입 연산자)
    Knight k3 { k2 };           // Knight 초기화

    vector<int> v1{1, 2, 3, 4}; // vector 초기화 1, 2, 3, 4 push_back

    int x = 0;
    double y{x};                // error

    Knight k4{};                // 기본생성자

    Knight k5{1, 2, 3, 4, 5};
    return 0;
}

class NullPtr
{
public:
    // 그 어떤 타입의 포인터와도 치환 가능
    template<typename T>
    operator T*() const
    {
        return 0;
    }
    // 그 어떤 타입의 멤버 포인터와도 치환 가능
    template<typename C, typename T>
    operator T C::*() const
    {
        return 0;
    }
    void operator&() = delete; // 주소갑 & 을 막는다.
};

typedef __int64 id;
using id2 = int;

// 1 ) 직관성
typedef void (*MyFunc)();
using MyFunc2 = void(*)();

// 2) Template
template<typename T>
using List = std::list<T>;

// 과거엔
template<typename T>
struct List2
{
    typedef std::list<T> type;
};

int main()
{
    List2<int>::type li2;
}

// unscped enum
enum PlayerType
{
    PT_Knight,
    PT_Archer,
    PT_Mage
}

enum PlayerType : char
{
    PT_Knight,
    PT_Archer,
    PT_Mage,
}

enum MonsterType
{
    PT_Knight // 실수로
}

enum class ObjectType
{
    Player,
    Monster,
    Projectile,
}

int main()
{
    double value = PT_Knight;                               // 에전의 enum 을 사용했을시 허용됬었다.

    double value = ObjectType::Player;                      // 허용 x
    double value = static_cast<double>(ObjectType::Player)  // 명시적만 허용
}

class Knight
{
public:

private:
    // 정의도지 않은 비공개 (private) 함수 --> 하지만 구현부에서는 돌아갈수있다. 그래서 완벽하게 막는 행위는 아니다.
    void operator=(const Knight& k);
    friend class Admin; // admin 에게는 허락 해주겠다.
private:
    int _hp = 100;
}

class Admin
{
public:
    void CopyKnight(const Knight& k)
    {

    }
}

int main()
{
    Knight k1;
    Knight k2;

    // 복사 연산자
    k1 = k2;
    return 0;
}

class Knight
{
public:
    void operator=(const Knight& k) = delete
}

class Admin
{
public:
    void CopyKnight(const Knight& k)
    {

    }
}

int main()
{
    Knight k1;
    Knight k2;

    // 복사 연산자
    k1 = k2; // delete 되버림
    return 0;
}

class Creature
{
public:
};

class Player : public Creature
{
public:
    virtual void Attack()
    {
        cout << "Player Attack" << endl;
    }
};

class Knight : public Player
{
public:
    virtual void Attack() override
    {
        cout << "Kngiht" << endl;
    }
    virtual void Attack() const //  member 변수를 변경 할수 없음
private:
    int _stamina = 100;
};

class Pet : public Knight
{
public:
    virtual void Attack() final // 마지막 봉인 : 자식에게 그만 주겠당
    {
        cout << "Pet" << endl;
    }
};

int main()
{
    Player* player = new Knight();
    player->Attack();
    return 0;
}

int main()
{
    int a = 3;

    a = 4;
    // 3 = a; Error : 식이 수정할수 없는 왼값이어야 된다. 

}

class Knight
{
public:
    int _hp = 100;
};

void TestKnight_LValueRef(Knight& knight){ knight._hp = 200 }
void TestKnight_ConstLValueRef(const Knight& knight){}          // 하지만 멤버 변수나 method 를 사용할수 없다. 원본 수정 No No...
void TestKnight_RValueRef(Knight&& knight){}                    // 오른값을 받는 특별한 아이를 지정. 이동대상!

int main()
{
    Knight k1;
    TestKnight_LValueRef(k1);
    TestKnight_LValueRef(Knight());         // 오른값으로 넘겨 줬을때는 Ref 로 넘길수 없다.
    TestKnight_ConstLValueRef(Knight());    // 허용 --> Knight() 가 잠시 사용하다가 없어질수 있지만, 읽기 용도로 쓰일수 있음
    TestKnight_RValueRef(k1);               // 왼값을 허용이 안된다.
    TestKnight_RValueRef(Knight());
    TestKnight_RValueRef(static_cast<Knight&&>(k1));
}

class Pet
{

};

class Knight
{
public:
    Knight(){ cout << "Knight()" << endl;}
    Knight(const Knight& knight)
    {
        cout << "const Knight" << endl;
    }
    ~Knight()
    {
        if(_pet)
            delete _pet;
    }

    // 이동 생성자
    Knight(Knight&& knight);

    void operator=(const Knight& knight)
    {
        cout << "operator=(const Knight&)" << endl;
        _hp = knight._hp;
        
        if (knight._pet)
            _pet = new Pet(*knight._pet);
    }

    // 이동 대입 연산자
    void operator=(Knight&& knight) noexcept
    {
        // 소유권을 넘겨버림
        cout << "operator=(Knight&&) "<< endl;
        _hp = knight._hp;
        _pet = knight._pet;

        knight._pet = nullptr;
    }
    
public:
    int _hp = 100;
    Pet* _pet = nullptr;
};

int main()
{
    Knight k2;
    k2._pet = new Pet();
    k2._hp = 1000;

    Knight k3;
    k3 = static_cast<Knight&&>(k2); // k2 는 버리고 k3 에서 k2 의 pet 을 뺐어온다. 원본은 날려도 된다. 즉 이동 가능!

    k4 = std::move(k3); // 오른쪽값 참조로 캐스팅 ---> static_cast<Knight&&>(k3); 이러면 k3 를 버리고 k4 가 소유권을 얕복으로 가져

    std::unique_ptr<Knight> uptr = std::make_unique<Knight>(); // 세상에 하나만 존재
    std::unique_ptr<Knight> uptr2 = uptr; // 복사 X
    std::unique_ptr<Knight> uptr2 = std::move(uptr); // 이렇게 이용
    return 0;
}

class Knight
{
public:
    Knight(){ cout << "Default Constructor" << endl;}
    Knight(const Knight& knight){ cout << "const Knight& knight" << endl; }
    Knight(Knight&&) noexcept {cout << "Move Constructor" << endl;}
    ~Knight(){ cout << "~Knight" << endl; }
};

void Test_RValueRef(Knight&& k)
{

}

void Test_Copy(Knight k)
{

}

template<typename T>
void Test_ForwardingRef(T&& param)
{
    Test_Copy(std::forward<T>(param));
}

int main()
{
    Knight k1;
    Test_RValueRef(std::move(k1));
    Test_ForwardingRef(std::move(k1));
    Test_ForwardingRef(k1);         // 경우에따라서 왼쪽 참조가 될수도 있고 오른쪽 참조가 될수도 있다.

    auto&& k2 = k1;                 // 참조는 참조인데 오른값이 아니다. 왼값참조로 되어있다!?
    auto&& k3 = std::move(k1);

    // 일반적일때는 사용되지 않지만, type deduction 할때 일어난다. 전달참조가 일어난다.

    return 0;
}

int main()
{
    Knight& k4 = k1;
    Knight&& k5 = std::move(k1);

    // Test_RValueRef(k5);         // 어 오른값을 안받네?

    Test_RValueRef(std::move(k5));
}

enum class ItemType
{
    None,
    Armor,
    Weapon,
    Jewelry,
    Consumable,
}

enum class Rarity
{
    Common,
    Rare,
    Unique
};

class Item
{
public:
    Item(){}
    Item(int itemId, Rarity rarity, ItemType type) : _itemId(itemId), _rarity(Rarity), _type(type)
    {

    }
public:
    int _itemId;
    Rarity _rarity = Rarity::Common;
    ItemType _type = ItemType::None;
}

int main()
{
    vector<Item> v;
    v.push_back(Item(1, Rarity::Common, ItemType::Weapon));
    v.push_back(Item(2, Rarity::Common, ItemType::Armor));
    v.push_back(Item(3, Rarity::Rare, ItemType::Jewelry));
    v.push_back(Item(4, Rarity::Unique, ItemType::Weapon));

    // lambda = 함수 객체를 손쉽게 만드는 문법
    {   
        // [](인자) {구현부} 기본 형식 --> lambda expression
        auto isUniqueLambda = [](Item& item){ return item._rarity == Rarity::Unique; }
        auto findIt = std::find_if(v.begin(), v.end(), isUniqueLambda)
        if (findIt != v.end())
            cout << "Item Id:" findIt->_itemId << endl;
    }

    {
        int itemId = 4;
        auto findByItemLambda = [=](Item& item){ return item._itemid == _itemId; };
        itemId = 10;
        auto findByItemLambda = [&](Item& item){ return item._itemid == _itemId; }; // 10 으로 바뀌었다.
    }

    {
        int itemId = 4;
        Rarity rarity = Rarity::Unique;
        ItemType type = ItemType::Weapon;
        auto findByItem = [=](Item& item)
        {
            return item._itemId == itemId && item._rarity == rarity && item._type == type;
        }

        auto findByItem = [itemId, rarity, type](Item& item)
        {
            return item._itemId == itemId && item._rarity == rarity && item._type == type; 
        }
    }

    {
        // bug-case
        class Knight
        {
        public:
            void ResetHpJob()
            {
                // auto f = [this](){} --> [=](){}
                // {
                //     this->_hp = 200;
                // }                                    // 버그
                return f;
            }
        public:
            int _hp = 100;
        }

        Knight* k = new Knight();
        auto job = k->RequestHpJob();
        delete k;
        job();
    }
}

class Knight
{
public:
    Knight(){}
    ~Knight(){}
    void Attack()
    {
        if (_target)
        {
            _target->_hp = _damage;
            cout << "Hp:" << _target->_hp << endl;
        }
    }
public:
    int _hp = 100;
    int _damage = 10;
    Knight* _target = nullptr;
}

int main()
{
    Knight* k1 = new Knight();
    Knight* k2 = new Knight();
    k1->_target = k2;
    delete k2;
    k1->Attack();
    return 0;
}

class RefCountBlock
{
public:
    int _refCount = 1; // 기본 값은 1. 
};

template<typename T>
class SharedPtr
{
public:
    SharedPtr(){}
    SharedPtr(T* ptr) : _ptr(ptr)
    {
        if (_ptr != nullptr)
        {
            _block = new RefCountBlock();
            cout << "RefCount : " << _block->_refCount << endl;
        }
    }
    SharedPtr(const SharedPtr& shared_ptr) : _ptr(shared_ptr._ptr), _block(shared_ptr._block)
    {
        if(_ptr != nullptr)
        {
            _block->_refCount++;
        }
    }
    ~SharedPtr()
    {
        if(_ptr != nullptr)
        {
            _block->_refCount--;

            // delete _ptr

            if (_block->_refCount ==0)
            {
                delete _ptr;
                delete _block;
            }
        }
    }

    void operator=(const SharedPtr& shared_ptr)
    {
        _ptr = shared_ptr._ptr;
        _block = shared_ptr._block;
    }
public:
    T* _ptr = nullptr;
    RefCountBlock* _block = nullptr; 
};

int main()
{
    SharedPtr<Knight> k1(new Knight());
    SharedPtr<Knight> k2 = k1;

    SharedPtr<Knight> k3;
    {
        SharedPtr<Knight>k4(new Knight());
        k4 = k1;
    }
}

class Knight
{
public:
    Knight(){}
    ~Knight(){}
    void Attack()
    {
        if (_target)
        {
            _target->_hp = _damage;
            cout << "Hp:" << _target->_hp << endl;
        }
    }
public:
    int _hp = 100;
    int _damage = 10;
    shared_ptr<Knight> _target = nullptr;
}

int main()
{
    shared_ptr<Knight> k1 = make_shared<Knight>(); // 빨리 동작
    {
        shared_ptr<Knight> k2 = make_shared<Knight>();
        k1->_target = k2;
    }

    k1->Atttack();
    return 0;
}

shared_ptr<Knight> k1 = make_sahred<Knight>();
{
    shared_ptr<Knight> k2 = make_shared<Knight>();
    k1 -> _target = k2;
    k2 -> _target = k1;
}

k1->_target = nullptr;
k2->_target = nullptr;

#include <vector>

int main()
{
    vector <int> v;
    v.push_back(1);
    v.push_back(2);
    v.push_back(4);
    v.push_back(5);

    const int size = v.size();
    for (int i = 0; i < size; i++)
    {
        cout << v[i] << endl;
    }

    return 0;
}

#include <vector>

int main()
{
    vector<int> v;

    for (int i = 0; i < 100; i++)
    {
        v.push_back(100);
        cout << v.size() << " " << v.capacity() << endl;
    }
    return 0;
}

#include <vector>

int main()
{
    vector<int> v;
    v.reserve(1000);
    for (int i = 0; i < 100; i++)
    {
        v.push_back(100);
        cout << v.size() << " " << v.capacity() << endl;
    }

    v.clear()
    vector<int>() swap(v);
    cout << v.size() << " " << v.capacity() << endl;
    return 0;
}

#include <vector>
int main()
{
    vector<int> v(10);
    for (vector<int>::size_type i = 0; i < v.size(); i++)
        v[i] = i;

    vector<int>::iterator it;
    int* ptr;

    it = v.begin();
    ptr = &v[0];

    cout << (*it) << endl;
    cout << (*ptr) << endl;
    return 0;
}

#include <vector>
int main()
{
    vector<int> v(10);
    for(vector<int>::size_type i = 0; i < v.size; i++)
        v[i] = i;
    vector<int>::iterator>> itBegin = v.begin();
    vector<int>::iterator itEnd = v.end();

    for (vector<int>::iterator it=v.begin(); i != v.end(); ++it)
    {
        cout << (*it) << endl;
    }

    int* ptrBegin = &v[0]; // v.begin()._Ptr
    int* ptrEnd = ptrBegin + 10; // v.end()._Ptr

    for (int*ptr=ptrBegin; ptr!=ptrEnd; ++ptr)
    {
        cout << (*it) << endl;
    }
    return 0;
}

vector<int>::const_iterator it = v.begin();
*it = 100; // const 기 때문에 바꿀수 없다.

// 역방향
for (vector<int>reverse_iterator it = v.begin(); it != v.end() ++it)
{
    cout << (*it) << endl;
}

// Init: [0][1][2][3][4]
v.insert(v.begin() + 2, 5);
// After: [0][1][5][2][3][4]

v.erase(v.begin()+2);
// After: [0][1][2][3][4]

v.erase(v.begin()+2, v.begin()+4);
// After: [0][1][4] 4 는 삭제 되지 않음

#include <vector>
int main()
{
    vector<int> v(10);
    for (vector<int>::size_type i=0; i < v.size(); i++)
        v[i] = i;
    
    for (vector<int>::iterator it = v.begin(); it != v.end())
    {
        int data = *it;
        if (data == 3)
        {
            //v.erase(it);
            it = v.erase(it);
        }
        else
        {
            ++it;
        }
    }

    return 0;
}

template<typename T>
class Iterator
{
public:
    Iterator() : _ptr(nullptr){}
    Iterator(T *ptr): _ptr(ptr){}

    Iterator& operator++()
    {
        _ptr++;
        return *this;
    }

    Iterator operator+(const int count)
    {
        Iterator temp = *this;
        temp._ptr += count;
        return temp;
    }

    Iterator operator++(int)
    {
        Iterator temp = *this;
        _ptr++;
        return temp;
    }

    Iterator& operator--()
    {
        _ptr++;
        return *this;
    }

    Iterator operator--(int)
    {
        Iterator temp = *this;
        _ptr++;
        return temp;
    }

    bool operator==(const Iterator& right)
    {
        return _ptr == right._ptr;
    }

    bool operator!=(const Iterator& right)
    {
        return _ptr != right._ptr;
    }

    T& operator*()
    {
        return *_ptr;
    }

public:
    T* _ptr;
};

template<typename T>
class Vector
{
public:
    Vecotr() : _data(nullptr), _size(0), _capacity(0){}

    ~Vecotr()
    {
        if(_data)
            delete[] _data;
    }

    void push_back(const T& val)
    {
        if(_size == _capacity)
        {
            int newCapacity = static_cast<int>(_capacity * 1.5);
            if (newCapacity == _capacity)
                newCapacity++;
            reserve(newCapacity);
        }

        _data[_size] = val;
        _size++;
    }

    void reserve(int capacity)
    {
        _capacity = capacity;
        T* newData = new T[_capacity];
        for (int i = 0; i < _size; i++)
            newData[i] = _data[i];
        
        // 기존에 있는 데이터를 날린다.
        if(_data)
            delete[] _data;
        
        _data = newData;
    }

    T& operator[](const int pos){ return _data[pos]; } // v[i] = i;
    int size() { return _size; }
    int capacity(){ return _capacity; }

private:
    T* _data;
    int _size;
    int _capacity;

    typedef Iterator<T> iterator;
    Iterator begin() { return iterator(&data[0]);}
    Iterator end() {return begin() + _size;}
};

int main()
{
    Vector<int> v;
    for (int i = 0; i < 100; i++)
    {
        v.push_back(100);
        cout << v.size() << " " << v.capacity() << endl;
    }

    for (int i = 0; i < v.size(); i++)
    {
        cout << v[i] << endl;
    }

    for (Vector<int>::iterator it = v.begin(); i != v.end() ++it)
    {
        cout << (*it) << endl;
    }
    return 0;
}

#include <list>
int main()
{
    list<int> l1;
    for (int i = 0; i < 100; i++)
        l1.push_back(i);
    
    li.push_front(10);      // vector 와 다르게 동작
    int size = l1.size();   // 
    // li.capacity() ?      // 동적배열인 형식이 아닌 Node 형식으로 동작

    int first = li.front();
    int last = li.back();

    // li[3] = 10;          // 임의 접근 안됨
    list<int>::iterator itBegin = li.begin();
    list<int>::iterator itEnd = li.end();

    for (list<int>::iterator it = li.begin(); it != li.end(); ++it)
    {
        cout << (*it) << endl;
    }

    li.insert(itBegin, 100);

    li.erase(li.begin());
    li.pop_front();
    li.remove(10);

    return 0;
}

class Node
{
public:
    Node*   _next;
    int     _data;
}

class Node2
{
public:
    Node2* _next;
    Node2* _prev;
    int    _data;
}

list<int> iterator itBegin = li.begin();
list<int> iterator itEnd = li.end();

// list<int>::iterator itTest1 = -- itBegin;    // 앞에서 맨뒤로 가는건 허용X
list<int>::iterator itTest2 = --itEnd;          // 앞으로 가는건 허용
// list<int>::iterator itTest3 = ++itEnd;       // 뒤에서 맨 앞으로 가는건 허용X

int* ptrBegin = &(li.front());
int* ptrEnd = &(li.end());

list<int>::iterator it2 = li.begin() + 10;

li.erase(li.begin() + 50) // 허용 되지 않음

list<int>::iterator it = li.begin();
for (int i =0; i < 50; i++)
    ++it;
li.erase(it);

list<int> li;
list<int>::iterator itRemember;
for  (int i = 0; i < 100; i++)
{
    if(i == 50)
    {
        itRemember = li.insert(li.end(), i);
    }
    else
    {
        li.push_back(i);
    }
}

li.erase(itRemember);

#include <list>
#include <iostream>
using namespace std;
template<typename T>
class Node
{
public:
    Node() : _next(nullptr), _prev(nullptr), _data(T()){}
    ~Node(const T& value) : _next(nullptr), _prev(nullptr), _data(value){}
public:
    Node*   _next;
    Node*   _prev;
    T       _data;
};

template<typename> T
class Iterator
{
public:
    Iterator() : _node(nullptr)
    {

    }

    Iterator(Node<T>* node) : _ node(node)
    {

    }
    // ++it
    Iterator<T>& operator++()
    {
        _node = _node->_next;
        return *this;
    }

    //it++
    Iterator<T> operator++(int)
    {
        Iterator<T> temp = *this;
        _node = _node->_next;
        return temp;
    }
    // --it
    Iterator<T>& operator++()
    {
        _node = _node->_prev;
        return *this;
    }

    // it--
    Iterator<T> operator++(int)
    {
        Iterator<T> temp = *this;
        _node = _node->_prev;
        return temp;
    }

    T& operator*()
    {
        return _node->_data;
    }

    bool operator==(const Iterator& right)
    {
        return _node == right._node;
    }

    bool operator !=(const Iterator& right)
    {
        return _node != right.node;
    }
public:
    Node<T>* _node;
}

template<typename T>
class List
{
public:
    List(): _size(0)
    {
        _header = new Node<T>();
        _header->_next = _header;
        _header->_prev = _header;
    }
    ~List()
    {
        while(_size > 0)
            pop_back();
        delete _header;
    }

    void push_back(const T& value)
    {
        AddNode(_header, value);
    }

    void pop_back()
    {
        RemoveNode(_header->_prev);
    }

    Node<T>* AddNode(Node<T>* before, const T& value)
    {
        Node<T>* node = new Node<T>(value);
        Node<T>* prevNode = before->_prev;
        prevNode->_next = node;
        node->_prev = prevNode;
        node->_next = before;
        before->_prev = node;

        _size++;
        return node;
    }

    Node<T>* RemoveNode(Node<T>* node)
    {
        Node<T>* _prevNode = node->_prev;
        Node<T>* _nextNode = node->_next;
        _prevNode->_next = _nextNode;
        _nextNode->_prev = _prevNode;

        delete node;
        _size--;
        return nextNode;
    }

    int size(){return _size;}

public:
    typedef Iterator<T> iterator;
    iterator begin() { return iterator(_header->_next); } // Header in the Last element would be the frist elem
    iterator end() { return iterator(_header); }
    iterator insert(iterator it, const T& value)
    {
        Node<T>* node = AddNode(it._node, value);
        return iterator(node);
    }

    iterator erase(iterator it)
    {
        Node<T>* node = RemoveNode(it._node);
        return iterator(node);
    }
public:
    Node<T>* _header;
    int _size;
};

int main()
{
    list<int> li;
    list<int>::iterator eraseIt;
    for (int i = 0; i < 10; i++)
    {
        if (i == 5)
        {
            eraseIt = li.insert(li.end(), i);
        }
        else
        {
            li.push_back(i);
        }
    }

    li.pop_back();
    li.erase(eraseIt);

    for (list<int>::iterator it = li.begin(); it != li.end(), ++it)
    {
        cout << (*it) << end;s
    }
    return 0;
}