int array1[] = {1,2,3,4,5};
int array2[5] = {0};

vector<int> v{1,2,3,4,5};//C++98无法编译

int main()
 {    
     // 内置类型变量
     int x1 = {10};
     int x2{10};
     int x3 = 1+2;
     int x4 = {1+2};
     int x5{1+2};
     // 数组
     int arr1[5] {1,2,3,4,5};
     int arr2[]{1,2,3,4,5};
     
     // 动态数组，在C++98中不支持
     int* arr3 = new int[5]{1,2,3,4,5};
     
     // 标准容器
     vector<int> v{1,2,3,4,5};
     map<int, int> m{{1,1}, {2,2,},{3,3},{4,4}};
     return 0;
 }

class Point
{
public:
    Point(int x = 0, int y = 0): _x(x), _y(y)
    {}
private:
    int _x;
    int _y;
};
 
int main()
{
    Point p{ 1, 2 };
    return 0;
}

#include <initializer_list>
template<class T>
class Vector {
public:
    // ...    
    Vector(initializer_list<T> l): _capacity(l.size()), _size(0)
    {
            _array = new T[_capacity];
            for(auto e : l)
                _array[_size++] = e;
    }
    
    Vector<T>& operator=(initializer_list<T> l) {
        delete[] _array;
        size_t i = 0;
        for (auto e : l)
                _array[i++] = e;
        return *this;
    }    
    // ...
private:
    T* _array;
    size_t _capacity;
    size_t _size;
};

#include <map>
#include <string>
int main()
{
	short a = 32670;
	short b = 32670;

	// c如果给成short，会造成数据丢失，如果能够让编译器根据a+b的结果推导c的实际类型，就不会存在问题
	short c = a + b;
	auto d = a + b;
	std::map<std::string, std::string> m{ { "apple", "苹果" }, { "banana", "香蕉" } };
	// 使用迭代器遍历容器, 迭代器类型太繁琐
	std::map<std::string, std::string>::iterator it = m.begin();
	while (it != m.end())
	{
		cout << it->first << " " << it->second << endl;
		++it;
	}
	auto its = m.begin();
	while (its != m.end())
	{
		cout << its->first << " " << its->second << endl;
		++its;
	}
	return 0;
}

template<class T1, class T2>
T1 Add(const T1& left, const T2& right)
{
    return left + right;
}

int main()
{
	double a = 10.9887;
	int b = 20;

	// 用decltype推演a+b的实际类型，作为定义c的类型
	decltype(a + b) c;
	c = a + b;
	cout << typeid(c).name() << endl;
	cout << c << endl;

	return 0;
}

void* GetMemory(size_t size)
{
    return malloc(size);
}
 
int main()
{
    // 如果没有带参数，推导函数的类型
    cout << typeid(decltype(GetMemory)).name() << endl;
    
    // 如果带参数列表，推导的是函数返回值的类型,注意：此处只是推演，不会执行函数
    cout << typeid(decltype(GetMemory(0))).name() <<endl;
    
    return 0;
}

for(元素类型 元素对象：容器对象)
{
　　循环体
}

class A
{
    virtual void foo();
    void bar();
};
 
class B : A
{
    void foo() const override; // 错误：B::foo 不覆盖 A::foo
                               // （签名不匹配）
    void foo() override; // OK：B::foo 覆盖 A::foo
    void bar() override; // 错误：A::bar 非虚
};

class Base
{
    virtual void foo();
};
 
class A : Base
{
    void foo() final; // Base::foo 被覆盖而 A::foo 是最终覆盖函数
    void bar() final; // 错误：非虚函数不能被覆盖或是 final
};
 
class B final : A // class B 为 final
{
    void foo() override; // 错误：foo 不能被覆盖，因为它在 A 中是 final
};
 
class C : B // 错误：B 为 final
{
};

/*
array 是一个类似vector的容器，但是是保存在栈区的，因此性能更好，不能够隐式转换为指针
编译时创建固定大小数组，只需要指定类型和大小即可

*/
void Tarray()
{
	array<int, 5>  arr={ 1, 2, 3, 4, 5 };//长度必须是常量或者常量表达式
	int * parr = &arr[0];
	parr = arr.data();
	parr = nullptr;//转换为指针的操作
	//forward_list<int> flist;
	//区别于list双向链表的单向链表，空间利用率和速率都更高
	/*
	新增两组无序容器：
	unordered_map
	unordered_multimap
	unordered_set
	unordered_multiset
	不同于set和map内部通过红黑树实现，而是hash表实现
	*/
}
void Ttuple()
{
	//就像一个可以容纳不同类型的结构体
	tuple<int, double, string> tps(12, 17.58, "pixel");
	auto tp = make_tuple(5, 12.125, "hello");//构造元组，类型推断为tuple<int,double,string>
	cout << get<2>(tp) << endl;//获取元素，无法使用变量下标
	int id;
	double bim;
	string item;
	tie(id, bim, item) = tp;//元组拆包
	cout << id << " " << bim << " " << item << endl;
	auto ntp = tuple_cat(tps, tp);//元组的连接
	/*
	pair，一个两个成员的结构体
	*/
	auto p1 = make_pair(12, 'c');
	pair<double, int> p2(12.125, 17);
	cout << p2.first << " " << p2.second << endl;
	p2 = make_pair(1, 1.2);
	p2 = p1;//一个含有成员函数的结构体
	//pair可以使用typedef进行简化声明
}
int main()
{
	Tarray();
	Ttuple();
	system("pause");
	return 0;
}

class A
{
public:
    A(int a): _a(a)
    {}
    // 显式缺省构造函数，由编译器生成
    A() = default;
    
    // 在类中声明，在类外定义时让编译器生成默认赋值运算符重载
    A& operator=(const A& a);
private:
    int _a;
};
 
A& A::operator=(const A& a) = default;
int main()
{
    A a1(10);
    A a2;
    a2 = a1;
    return 0;
}

class A
{
public:
	A(int a) : _a(a)
	{}

	// 禁止编译器生成默认的拷贝构造函数以及赋值运算符重载
	A(const A&) = delete;
	A& operator=(const A&) = delete;
private:
	int _a;
};

int main()
{
	A a1(10);
	// 编译失败，因为该类没有拷贝构造函数
		//A a2(a1);
	// 编译失败，因为该类没有赋值运算符重载
	A a3(20);
		//a3 = a2;
	return 0;
}

void Swap(int& left, int& right)
{
    int temp = left;
    left = right;
    right = temp;
}
 
int main()
{
    int a = 10;
    int b = 20;
    Swap(a, b);
}

int Add(int a, int b)
{
    return a + b;
}
 
int main()
{
    const int&& ra = 10;
    
    // 引用函数返回值，返回值是一个临时变量，为右值
    int&& rRet = Add(10, 20);
    return 0;
}

int main()
{
    // 普通类型引用只能引用左值，不能引用右值
    int a = 10;
    int& ra1 = a;   // ra为a的别名
    //int& ra2 = 10;   // 编译失败，因为10是右值
    
    const int& ra3 = 10;
    const int& ra4 = a;
    return 0;
}

int main()
{
    // 10纯右值，本来只是一个符号，没有具体的空间，
    // 右值引用变量r1在定义过程中，编译器产生了一个临时变量，r1实际引用的是临时变量
    int&& r1 = 10;
    r1 = 100;
 
    int a = 10;
    int&& r2 = a;  // 编译失败：右值引用不能引用左值
    return 0;
}

class String
{
public:
	String(char* str = "")
	{
		if (nullptr == str)
			str = "";
		_str = new char[strlen(str) + 1];
		strcpy(_str, str);
	}

	String(const String& s)
		: _str(new char[strlen(s._str) + 1])
	{
		strcpy(_str, s._str);
	}
	String& operator=(const String& s)
	{
		if (this != &s)
		{
			char* pTemp = new char[strlen(s._str) + 1];
			strcpy(pTemp, s._str);
			delete[] _str;
			_str = pTemp;
		}
		return *this;
	}

	String operator+(const String& s)
	{
		char* pTemp = new char[strlen(_str) + strlen(s._str) + 1];
		strcpy(pTemp, _str);
		strcpy(pTemp + strlen(_str), s._str);
		String strRet(pTemp);
		return strRet;
	}

	~String()
	{
		if (_str) delete[] _str;
	}
private:
	char* _str;
};

int main()
{
	String s1("hello");
	String s2("world");
	String s3(s1 + s2);
	return 0;
}

String(String&& s)
    : _str(s._str)
{ 
        s._str = nullptr;
}   

template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
    // forward _Arg as movable
    return ((typename remove_reference<_Ty>::type&&)_Arg);
}

class Person
{
public:
	Person(char* name, char* sex, int age)
		: _name(name)
		, _sex(sex)
		, _age(age)
	{}

	Person(const Person& p)
		: _name(p._name)
		, _sex(p._sex)
		, _age(p._age)
	{}

#if 0

	Person(Person&& p)
		: _name(p._name)
		, _sex(p._sex)
		, _age(p._age)
	{}

#else
	Person(Person&& p)
		: _name(move(p._name))
		, _sex(move(p._sex))
		, _age(p._age)
	{}

#endif

private:
	string _name;
	string _sex;
	int _age;
};

Person GetTempPerson()
{
	Person p("prety", "male", 18);
	return p;
}

int main()
{
	Person p(GetTempPerson());
	return 0;
}

void Fun(int &x){ cout << "lvalue ref" << endl; }
void Fun(int &&x){ cout << "rvalue ref" << endl; }
void Fun(const int &x){ cout << "const lvalue ref" << endl; }
void Fun(const int &&x){ cout << "const rvalue ref" << endl; }

template<typename T>
void PerfectForward(T &&t){ Fun(std::forward<T>(t)); }

int main()
{
	PerfectForward(10); // rvalue ref

	int a;
	PerfectForward(a); // lvalue ref
	PerfectForward(std::move(a)); // rvalue ref

	const int b = 8;
	PerfectForward(b); // const lvalue ref
	PerfectForward(std::move(b)); // const rvalue ref

	return 0;
}

int main()
{
    string s1("hello");
    string s2(" world");
    string s3 = s1 + s2;   // s3是用s1和s2拼接完成之后的结果拷贝构造的新对象
    stirng&& s4 = s1 + s2; // s4就是s1和s2拼接完成之后结果的别名
    return 0;
}

#include <algorithm>
#include <functional>
int main()
{
    int array[] = {4,1,8,5,3,7,0,9,2,6};
    
    // 默认按照小于比较，排出来结果是升序
    std::sort(array, array+sizeof(array)/sizeof(array[0]));
    
    // 如果需要降序，需要改变元素的比较规则
    std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
    return 0;
}

struct Goods
{
    string _name;
    double _price;
};
 
struct Compare
{
    bool operator()(const Goods& gl, const Goods& gr)
    {
        return gl._price <= gr._price;
    }
};
 
int main()
{
    Goods gds[] = { { "苹果", 2.1 }, { "相交", 3 }, { "橙子", 2.2 }, {"菠萝", 1.5} };
    sort(gds, gds+sizeof(gds) / sizeof(gds[0]), Compare());
    return 0;
}

int main()
{
    Goods gds[] = { { "苹果", 2.1 }, { "相交", 3 }, { "橙子", 2.2 }, {"菠萝", 1.5} };
    sort(gds, gds + sizeof(gds) / sizeof(gds[0]),
     [](const Goods& l, const Goods& r)->bool{
    return l._price < r._price;});
    return 0;
}

[capture-list] (parameters) 
mutable -> return-type { statement }

int main()
{
	// 最简单的lambda表达式, 该lambda表达式没有任何意义
	[]{};

	// 省略参数列表和返回值类型，返回值类型由编译器推导为int
	int a = 3, b = 4;
	[=]{return a + 3; };

	// 省略了返回值类型，无返回值类型
	auto fun1 = [&](int c){b = a + c; };
	fun1(10);
		cout << a << " " << b << endl;

	// 各部分都很完善的lambda函数
	auto fun2 = [=, &b](int c)->int{return b += a + c; };
	cout << fun2(10) << endl;

	// 复制捕捉x

	int x = 10;
	auto add_x = [x](int a) mutable { x *= 2; return a + x; };
	cout << add_x(10) << endl;

	return 0;
}

void(*PF)();
int main()
{
	auto f1 = []{cout << "hello world" << endl; };
	auto f2 = []{cout << "hello world" << endl; };

	//f1 = f2;    // 编译失败--->提示找不到operator=()
	// 允许使用一个lambda表达式拷贝构造一个新的副本
	auto f3(f2);
	f3();

	// 可以将lambda表达式赋值给相同类型的函数指针
	PF = f2;
	PF();
	return 0;
}

class Rate
{
public:
    Rate(double rate): _rate(rate)
    {}
 
    double operator()(double money, int year)
    { return money * _rate * year;}
 
private:
    double _rate;
};
 
int main()
{
    // 函数对象
    double rate = 0.49;
    Rate r1(rate);
    r1(10000, 2);
 
    // lamber
    auto r2 = [=](double monty, int year)->double{return monty*rate*year; };
    r2(10000, 2);
    return 0;
}

// vs下查看
typedef struct
{   /* thread identifier for Win32 */
    void *_Hnd; /* Win32 HANDLE */
    unsigned int _Id;
} _Thrd_imp_t;

void ThreadFunc(int a)
{
	cout << "Thread1" << a << endl;
}

class TF
{
public:
	void operator()()
	{
		cout << "Thread3" << endl;
	}
};

int main()
{
	// 线程函数为函数指针
	thread t1(ThreadFunc, 10);

	// 线程函数为lambda表达式
	thread t2([]{cout << "Thread2" << endl; });

	// 线程函数为函数对象
	TF tf;
	thread t3(tf);

	t1.join();
	t2.join();
	t3.join();
	cout << "Main thread!" << endl;
	return 0;
}

void ThreadFunc1(int& x)
{
	x += 10;
}

void ThreadFunc2(int* x)
{
	*x += 10;
}

int main()
{
	int a = 10;

	// 在线程函数中对a修改，不会影响外部实参，因为：线程函数参数虽然是引用方式，但其实际引用的是线程栈中的拷贝
	thread t1(ThreadFunc1, a);
	t1.join();
	cout << a << endl;

	// 如果想要通过形参改变外部实参时，必须借助std::ref()函数
	thread t2(ThreadFunc1, std::ref(a));
	t2.join();
	cout << a << endl;

	// 地址的拷贝
	thread t3(ThreadFunc2, &a);
	t3.join();
	cout << a << endl;
	return 0;
}

// jion()的误用一
void ThreadFunc() { cout<<"ThreadFunc()"<<endl; }
bool DoSomething() { return false; }
int main()
{
    std::thread t(ThreadFunc);
    if(!DoSomething())
        return -1;
    
    t.join();
    return 0;
}
/*
说明：如果DoSomething()函数返回false,主线程将会结束，jion()没有调用，线程资源没有回收，
造成资源泄漏。
*/
 
// jion()的误用二
void ThreadFunc() { cout<<"ThreadFunc()"<<endl; }
void Test1() { throw 1; }
void Test2()
{
    int* p = new int[10];
    std::thread t(ThreadFunc);
    try
    {
        Test1();
    }
    catch(...)
    {
        delete[] p;
        throw;
    }
    
    t.jion();
}

#include <iostream>
using namespace std;
#include <thread>
#include <mutex>
 
std::mutex m;
unsigned long sum = 0L;
 
void fun(size_t num)
{
    for (size_t i = 0; i < num; ++i)
    {
        m.lock();
        sum++;
        m.unlock();
    }
}
 
int main()
{
    cout << "Before joining,sum = " << sum << std::endl;
 
    thread t1(fun, 10000000);
    thread t2(fun, 10000000);
    t1.join();
    t2.join();
 
    cout << "After joining,sum = " << sum << std::endl;
    return 0;
}

#include<iostream>
#include <atomic>
using namespace std;
atomic_long sum{ 0 };

void fun(size_t num)
{
	for (size_t i = 0; i < num; ++i)
		sum++;   // 原子操作
}

int main()
{
	cout << "Before joining, sum = " << sum << std::endl;

	thread t1(fun, 1000000);
	thread t2(fun, 1000000);
	t1.join();
	t2.join();

	cout << "After joining, sum = " << sum << std::endl;
	return 0;
}

atmoic<T> t;    // 声明一个类型为T的原子类型变量t

#include <atomic>
int main()
{
    atomic<int> a1(0);
    //atomic<int> a2(a1);    // 编译失败
    atomic<int> a2(0);
    //a2 = a1;               // 编译失败
    return 0;
}

 template<class _Mutex>
class lock_guard
{
public:
    // 在构造lock_gard时，_Mtx还没有被上锁
    explicit lock_guard(_Mutex& _Mtx)
        : _MyMutex(_Mtx)
    {
        _MyMutex.lock();
    }
 
    // 在构造lock_gard时，_Mtx已经被上锁，此处不需要再上锁
    lock_guard(_Mutex& _Mtx, adopt_lock_t)
        : _MyMutex(_Mtx)
    {}
 
    ~lock_guard() _NOEXCEPT
    {
        _MyMutex.unlock();
    }
 
    lock_guard(const lock_guard&) = delete;
    lock_guard& operator=(const lock_guard&) = delete;
 
private:
    _Mutex& _MyMutex;
};