详解C++之C++11的牛逼特性

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

vector<int> v{1,2,3,4,5};

// 内置类型
int x1 = {10};
int x2{10}
// 数组
int arr1[5] {1,2,3,4,5}
int arr2[]{1,2,3,4,5};
// 标准容器
vector<int> v{1,2,3}
map<int,int> m{{1,1},{2,2}}
// 自定义类型
class Point
{
int x;
int y;
}
Power p{1,2};

#include<initializer_list>
template<class T>
class Vector{
public:
	Vecto(initializer_list<T> l)
		:_capacity(l.size())
		,_size(0){
			_array = new T[_capacity];
			for(auto e : l)
				_array[_size++] = 3;
		}
private;
	T* _array;
	size_t _capacity;
	size_t _size;
};

// 不使用auto需要写很长的迭代器的类型
map<string,string> m;
map<string,string>::iterator it1 = m.begin();
// 使用auto就很简单
auto it2 = m.begin();

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

// 推演表达式作为变量的定义类型
int a = 1,b=2;
decltype(a+b) c;
cout<<typeid(c).name()<<endl;

// 推演函数的返回值类型
void GetMemory(size_t size){
	return malloc(size);
}
cout<<typeid(decltype(GetMemory)).name()<<endl;

vector<int> v{1,2,3,4,5};
for(const auto& e : v)
	cout<<e<<' ';
cout<<endl;

class Info
{
public;
	Info()
		:_type(0)
		,_name('s')
		{}
	Info(int type)
		:_type(type)
		,_name('a')
		{}
	Info(char a)
		:_type(0)
		,_name(a)
		{}
pirvate;
	int _type;
	char _name;
};

class Info
{
// 目标构造函数
public:
	Info()
		:_type(0)
		,_a('a')
	{}
// 委派构造函数
	Info(int type)
		:Info()
		{
			_type = type;
		}
private;
	int _type = 0;
	char _a = 'a';
};

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;

class A
{
A(int a)
	:_a(a)
{}
A(constA&) = delete; // 禁止编译器生成默认的拷贝构造函数
private:
	int _a;
};

class String
{
public:
	String(char* str = '")
	{
		if(str == nullptr)
			_str = "";
		_str = new char[strlen(str)+1];
		strcpy(_str,str);
	}
	String(const String& s)
		:_str(new char[strlen(c._str)+1])
	{
		strcpy(_str,s._str);
	}
	~String()
	{
		if(_str)
			delete[] _str;
	}
private:
	char* _str;
};

String GetString(char* pStr)
{
	String strTemp(pStr);
	return strTemp;
}
	
int main()
{
	String s1("hello");
	String s2(GetString("world"));
	return 0;
}

String&& GetString(char* pStr)
{
	String strTemp(pStr);
	return strTemp;
}
	
int main()
{
	String s1("hello");
	String s2(GetString("world"));
	return 0;
}

String GetString(char* pStr) {
return String(pStr);
}
int main()
{
String&& s = GetString("hello");
return 0; }

int a = 10;
int&& a1; // 未初始化，编译失败
int&& a2 = a; // 编译失败，a是一个左值
// 左值是可以改变的值

Object()
Object(const T&)
Object(T&&)

String(const String&&);
const String GetString();

class String
{
public:
	String(char* str = "")
	{
		if(str == nullptr)
			str = "";
		_str = new char[strlen(str)+1];
		strcpy(_str,str);
	}
	// 拷贝构造
	// String s(左值对象)
	String(const String& s)
		:_str(new char[strlen(s._str) + 1])
		{
			strcpy(_str,s_str);
		}
	// 移动构造
	// String s(将亡值对象)
	String(String&& s)
		:_str(nullptr)
		{
			swap(_str,s._str);
		}
	// 赋值
	String& operator=(const String& s)
	{
		if(this != &s)
		{
			char* tmp = new char[strlen(s._str)+1];
			stcpy(tmp,s._str);
			delete[] _str;
			_str = tmp;
		}
		return *this;
	}
	// 移动赋值
	String& operator=(String&& s)
	{
		swap(_str,s._str);
		return *this;
	}
	~String()
	{
		if(_str)
			delete[] _str;
	}
	// s1 += s2 体现左值引用，传参和传值的位置减少拷贝
	String& operator+=(const String& s)
	{
		// this->Append(s.c_str());
		return *thisl
	}
	// s1 + s2
	String operator+(const String& s)
	{
		String tmp(*this);
		// tmp.Append(s.c_str());
		return tmp;
	}
	const char* c_str()
	{
		return _str;
	}
private:
	char* _str;
};
int main()
{
	String s1("hello"); // 实例化s1时会调用移动构造
	String s2("world");
	String ret 
	ret = s1 + s2 // +返回的是临时对象，这里会调用移动构造和移动赋值，减少拷贝
	
	vector<String> v;
	String str("world");
	v.push_back(str); // 这里调用拷贝构造函数
	v.push_back(move(str)); // 这里调用移动构造，减少一次拷贝
	return 0;
}

void Func(int x)
{
	// ......
}
template<typename T>
void PerfectForward(T t)
{
	Fun(t);
}

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; }

vector<int> v{1,4,3,2,7,6,5};
// 默认按照小于比较，结果是升序
sort(v.begin(),v.end());
// 传入第三个模板参数std::greater<T>(),按照大于比较，默认是降序
sort(v.begin(), v.end(),greater<int>());

int main()
{
	// 最简单的lambda表达式
	[]{};
	// 省略参数列表和返回值类型,返回值类型有编译器推演为int
	int a=3,b=4;
	[=]{return a+3;};
	// 省略返回值类型
	auto fun1 = [&](int c){b = a + c;};
	// 各部分完整的lambda函数
	auto fun2 = [=,&b](int c)->int(return += a + c;);
	// 复制捕捉x
	int x = 10;
	auto add_x = [x](int a)mutable{x *= 2; return a + x;};
	return 0;
}

a [var]:表示值传递方式捕获变量var
b [=]:表示值传递方式捕获所有父作用域中的变量(包括this)
c [&var]:表示引用传递变量var
d [&]:表示引用传递捕获所有父作用域中的变量(this)
e [this]：表示值传递方式捕获当前的this指针

a 父作用域包含lambda函数的语句块
b 语法上捕获列表可由多个捕获项组成，并以逗号分隔
	比如：[=,&a,&b]：以引用传递的方式捕获变量a 和 b，值传递的方式捕获其它所有变量.
	[&,a,this]；值传递的方式捕获变量a和this，引用方式捕获其它变量。
	捕捉列表不允许变量重复传递，否则会导致编译错误。比如：[=,a]以传值的方式捕获了所有变量，又重复捕捉a
c 块作用域以外的lambda函数捕捉列表必须为空
e 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错
f lambda表达式之间不能相互赋值，即使看起来类型相同.

void (*PF)();
int main()
{
	auto f1 = []{cout<<"hello world"<<endl;};
	auto f2 = []{cout<<"hello world"<<endl;};
	f1= f2; // 这里会编译失败，提示找不到operator=()
	auto f3(f2); // 允许使用一个lambda表达式拷贝一个新的福分
	PF = f2; // 可以将lambda表达式赋值给相同类型的指针
	return 0;
}

typedef bool (*GTF) (int, int);
bool greater_func1(int l, int r)
{
	return l > r;
}

struct greater_func2
{
	bool operator()(int l, int r)
	{
		return l > r;
	}
};

int main()
{
	// 函数指针
	GTF f1 = greater_func1; // typedef 定义
 // bool (*f1) (int, int) = greater_func1; // 不typedef ,直接原生写法，可读性差
 cout<< f1(1,2)<<endl;
 // 仿函数
 greater_func2 f2;
 cout<< f2(1,2)<<endl;
 // lamba表达式
 auto f3 = [] (int l, int r) ->bool{return l > r;};
 cout<< f3(1,2)<<endl;
 
	int a[] = {1,2,4,5,3,7,6,9,8};
	sort(a,a+sizeof(a)/sizeof(a[0]),f1);
	sort(a,a+sizeof(a)/sizeof(a[0]),f2);
	sort(a,a+sizeof(a)/sizeof(a[0]),f3);
	// sort函数第三个模板参数能接受函数指针，仿函数、lambda表达式，是因为其第三个参数是一个模板custom (2)	
	template <class RandomAccessIterator, class Compare>
 void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
 
	return 0;
}

struct Goods
{
	string _name;
	double _price;
	double _appraise;
};

int main()
{
	Goods gds[] = { { "苹果", 2.1, 10 }, { "相交", 3, 8 }, { "橙子", 2.2, 7 }, { "菠萝", 1.5, 10 } };

	sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& g1, const Goods& g2)->bool
	{return g1._price > g2._price; });

	sort(gds, gds + sizeof(gds) / sizeof(gds[0]), [](const Goods& g1, const Goods& g2)->bool
	{return g1._appraise > g2._appraise; });

	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);
// 仿函数
auto r2 = [=](double monty, int year)->double{return monty*rate*year; };
r2(10000, 2);
return 0; }

#include<iostream>
#include<thread>

void fun()
{
	std::cout << "A new thread!" << std::endl;
}
int main()
{
	std::thread t(fun);
	t.join();
	std::cout << "Main thread!" << std::endl;
	system("pause");
	return 0;
}

// 使用lambda表达式作为线程函数创建线程
int main()
{
	int n1 = 1;
	int n2 = 2;
	std::thread t([&](int addNum){n1 += addNum; n2 += addNum; }, 3);
	t.join();
	std::cout << n1 << " " << n2 << std:: endl;
	system("pause");
	return 0;
}

int main()
{
	int n1 = 1;
	int n2 = 2;
	std::thread t([&](int addNum){n1 += addNum; n2 += addNum; }, 3);
	std::cout << "join before,joinable=" << t.joinable() << std::endl;
	t.join();
	std::cout << "join after,joinable=" << t.joinable() << std::endl;
	system("pause");
	return 0;
}
// 执行结果：
join before,joinable=1
join after,joinable=0

int main()
{
	int n1 = 1;
	int n2 = 2;
	std::thread t([&](int addNum){n1 += addNum; n2 += addNum; }, 3);
	std::cout << "join before,joinable=" << t.joinable() << std::endl;
	t.detach();
	std::cout << "join after,joinable=" << t.joinable() << std::endl;
	system("pause");
	return 0;
}

int sum = 0;

void fun(size_t num)
{
	for (size_t i = 0; i < num; i++)
		sum++;
}

int main()
{
	std::cout << "before,sum=" << sum << std::endl;
	std::thread t1(fun, 100000000);
	std::thread t2(fun, 100000000);
	t1.join();
	t2.join();
	std::cout << "After,sum=" << sum << std::endl;
	system("pause");
	return 0;
}

int sum = 0;
std::mutex m;

void fun(size_t num)
{
	for (size_t i = 0; i < num; i++)
	{
		m.lock();
		sum++;
		m.unlock();
	}
}

#include<thread>
#include<mutex>
#include<atomic>

std::atomic_int sum{ 0 };

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

int main()
{
	std::cout << "before,sum=" << sum << std::endl;
	std::thread t1(fun, 10000000);
	std::thread t2(fun, 10000000);
	t1.join();
	t2.join();
	std::cout << "After,sum=" << sum << std::endl;
	system("pause");
	return 0;
}