C++11：现代C++的演变与提升

//在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。
struct Point
{
	int x;
	int y;
};

int main()
{
	int arr[] = { 1,2,3,4,5 };
	int arr2[5] = { 1 };
	Point p = { 1,2 };
	return 0;
}

struct Point
{
	int x;
	int y;
};

int main()
{
	int x1 = 1;
	int x2{ 2 };

	int arr1[]{ 1,2,3,4,5 };
	int arr2[5]{ 1 };

	Point p{ 1,2 };

	//甚至列表初始化也能运用到new表达式中
	int* pa = new int[4] {0};
	return 0;
}

void foo(std::initializer_list<int> values)
{
    for (auto value : values)
    {
        std::cout << value << " ";
    }
}


int main()
{
    foo({ 1,2,3,4,5 });
    return 0;
}

class MyClass {
public:
    MyClass(std::initializer_list<int> list) 
    {
        for (auto elem : list) 
        {
            std::cout << elem << " ";
        }
        std::cout << std::endl;
    }
};

MyClass obj = {1, 2, 3, 4};


//用initializer_list 来接收一个初始化列表，并打印它的内容。

std::vector<int> vec = {1, 2, 3, 4, 5};
std::set<int> s = {10, 20, 30};

void sum(std::initializer_list<int> list) 
{
    int result = 0;
    for (auto elem : list) 
    {
        result += elem;
    }
    std::cout << "Sum: " << result << std::endl;
}

sum({1, 2, 3, 4});  //输出结果为10

#include<map>
#include<string>
int main()
{
	int i = 10;
	auto p = &i;
	auto pf = strcpy;
	cout << typeid(p).name() << endl;
	cout << typeid(pf).name() << endl;
	map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
	//map<string, string>::iterator it = dict.begin();
	auto it = dict.begin();
	return 0;
}

int main()
{
	map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
	auto it = dict.begin();
	vector<decltype(it)>arr;
	return 0;
}

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

for (declaration : container) 
{
    // 循环体
}

int main() 
{
    int arr[] = {1, 2, 3, 4, 5};
    
    for (int x : arr) 
    {
        x *= 2;  // 修改的是副本，不会影响原数组
    }
    
    for (int x : arr) 
    {
        cout << x << " ";  // 输出依然是 1 2 3 4 5
    }

    for (int& x : arr) 
    {
        x *= 2;  // 修改的是原数组
    }
    
    for (int x : arr) 
    {
        cout << x << " ";  // 输出 2 4 6 8 10
    }
    return 0;
}

// 以下的p、b、c、*p都是左值
int* p = new int(0);
int b = 1;
const int c = 2;

// 以下几个是对上面左值的左值引用
int*& rp = p;
int& rb = b;
const int& rc = c;
int& pvalue = *p;

// 以下几个都是常见的右值
10;
x + y;
fmin(x, y);

// 以下几个都是对右值的右值引用
int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x, y);

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

int main()
{
	int&& r1 = 10;

	int a = 10;
	int&& r2 = a;//会报错，无法将左值绑定到右值引用

	// 右值引用可以引用move以后的左值
	int&& r3 = move(a);

	return 0;
}

class string
{
public:
	string(const char* s = "")//默认构造
		:size(strlen(s))
		, capacity(size)
	{
		str = new char[capacity + 1];
		strcpy(str, s);
	}
	void swap(string& s)
	{
		std::swap(str, s.str);
		std::swap(size, s.size);
		std::swap(capacity, s.capacity);
	}

	string(const string& s)//拷贝构造
		:str(nullptr)
	{
		cout << "拷贝构造" << endl;
		string tmp(s.str);
		swap(tmp);
	}

	string& operator=(const string& s)
	{
		cout << "赋值重载" << endl;
		string tmp(s);
		swap(tmp);
	}

	string(string&& s)
		:str(nullptr)
		,size(0)
		,capacity(0)
	{
		cout << "移动构造" << endl;
		swap(s);
	}

	string& operator=(string&& s)
	{
		cout << "移动赋值" << endl;
		swap(s);
		return *this;
	}

	~string()
	{

		delete[]str;
		str = nullptr;
	}

	char& operator[](size_t pos)
	{
		assert(pos < size);
		return str[pos];
	}
	void reserve(size_t n)
	{
		if (n > capacity)
		{
			char* tmp = new char[n + 1];
			strcpy(tmp, str);
			delete[] str;
			str = tmp;
			capacity = n;
		}
	}

	void push_back(char ch)
	{
		if (size >= capacity)
		{
			size_t newcapacity = capacity == 0 ? 4 : capacity * 2;
			reserve(newcapacity);
		}
		str[size] = ch;
		++size;
		str[size] = '\0';
	}


	//string operator+=(char ch)
	string& operator+=(char ch)
	{
		push_back(ch);
		return *this;
	}

	const char* c_str() const
	{
		return str;
	}

private:
	char* str;
	size_t size;
	size_t capacity;//不包含最后做标识的\0
};

void func1(bit::string s)
{}
void func2(const bit::string& s)
{}
int main()
{
 bit::string s1("hello world");
 // func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值
 func1(s1);
 func2(s1);
 // string operator+=(char ch) 传值返回存在深拷贝
 // string& operator+=(char ch) 传左值引用没有拷贝提高了效率
 s1 += '!';
 return 0;
}

int main()
{
 test::string s1("hello world");
 // 这里s1是左值，调用的是拷贝构造
 test::string s2(s1);
 // 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
 // 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
 // 资源被转移给了s3，s1被置空了。
 test::string s3(std::move(s1));
 return 0;
}

void Fun(int &x)
{ 
    cout << "左值引用" << endl; 
}
void Fun(const int &x) 
{ 
    cout << "const 左值引用" << endl;
}

void Fun(int &&x)
{ 
    cout << "右值引用" << endl; 
}
void Fun(const int &&x)
{ 
    cout << "const 右值引用" << endl; 
}

// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发
template<typename T>
void PerfectForward(T&& t)
{
 Fun(t);
}
int main()
{
 PerfectForward(10);           // 右值
 int a;
 PerfectForward(a);            // 左值
 PerfectForward(std::move(a)); // 右值
 const int b = 8;
 PerfectForward(b);      // const 左值
 PerfectForward(std::move(b)); // const 右值
 return 0;
}

void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
void Fun(int &&x){ cout << "右值引用" << endl; }
void Fun(const int &&x){ cout << "const 右值引用" << endl; }
// std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
template<typename T>
void PerfectForward(T&& t)
{
 Fun(std::forward<T>(t));
}
int main()
{
 PerfectForward(10);           // 右值
 int a;
 PerfectForward(a);            // 左值
 PerfectForward(std::move(a)); // 右值
 const int b = 8;
 PerfectForward(b);      // const 左值
 PerfectForward(std::move(b)); // const 右值
 return 0;
}

struct Goods
{
 string _name;  // 名字
 double _price; // 价格
 int _evaluate; // 评价
 Goods(const char* str, double price, int evaluate)
 :_name(str)
 , _price(price)
 , _evaluate(evaluate)
 {}
};

int main()
{
 vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 
3 }, { "菠萝", 1.5, 4 } };
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._price < g2._price; });
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._price > g2._price; });
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._evaluate < g2._evaluate; });
 sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
 return g1._evaluate > g2._evaluate; });
}

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

#include <iostream>
#include <functional>

int add(int a, int b) 
{
    return a + b;
}

int main() {
    std::function<int(int, int)> func = add;//std::function<int(int)> 可以存储任何接受一个 int 并返回 int 的可调用对象
    std::cout << func(2, 3) << std::endl; // 输出 5
    return 0;
}

// 使用举例
#include <functional>
int Plus(int a, int b)
{
 return a + b;
}
class Sub
{
public:
 int sub(int a, int b)
 {
 return a - b;
 }
};

int main()
{
 //表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定
 std::function<int(int, int)> func1 = std::bind(Plus, placeholders::_1, 
placeholders::_2);
 //auto func1 = std::bind(Plus, placeholders::_1, placeholders::_2);
 //func2的类型为 function<void(int, int, int)> 与func1类型一样
 //表示绑定函数 plus 的第一，二为： 1， 2
 auto  func2 = std::bind(Plus, 1, 2);   
 cout << func1(1, 2) << endl;
 cout << func2() << endl;
 Sub s;
 // 绑定成员函数
 std::function<int(int, int)> func3 = std::bind(&Sub::sub, s, 
 placeholders::_1, placeholders::_2);
 //参数调换顺序
 std::function<int(int, int)> func4 = std::bind(&Sub::sub, s, 
placeholders::_2, placeholders::_1);
 cout << func3(1, 2) << endl; 
 cout << func4(1, 2) << endl;
 return 0;
}