【C++】C++11风云再起：语法新纪元，性能新巅峰！

struct Triangle
{
	int _a;
	int _b;
	int _c;
};

int main()
{
	//用{}对数组和结构体进行初始化
	int arr1[] = { 2, 4, 6, 8, 7 };
	int arr2[10] = { 3, 4, 5 };
	Triangle t = { 3, 4, 5 };

	return 0;
}

//直接列表初始化，可以省略掉 = 
int x = { 10 };
int y{ 5 };
double d{3.14}

struct Triangle
{
	int _a;
	int _b;
	int _c;
};

Triangle t1 = { 3, 4, 5 };
Triangle t2{ 6, 8, 10 };

//引用临时对象需要加const
const Triangle& t3 = { 6, 6, 6 };

vector (initializer_list<value_type> il, const allocator_type& alloc = 
allocator_type());

 list (initializer_list<value_type> il, const allocator_type& alloc = 
allocator_type());

map (initializer_list<value_type> il,const key_compare& comp = 
key_compare(),const allocator_type& alloc = allocator_type());

//调用了initializer_list版本的构造
vector<int> v1({ 1,2,3,4 });

//列表初始化，构造临时对象，再拷贝构造，但编译器会直接优化成构造（=可以省略）
vector<int> v2 = { 1,2,3,4 };
const vector<int>& v3 = { 1,2,3,4 };

//pair的{}的初始化和map的initializer_list构造结合
map<string, string> dict ( { {"apples", "苹果"}, {"index", "下标"} } );

//initializer_list版本的赋值重载
v1 = { 4,5,6,7 };

template<typename... Args>
void functionName(Args... args) {
    // 函数体
}

template<class ...Args>
void CountArgs(Args&&...args)	//右值引用
{
	cout << sizeof...(args) << endl;
}

int main()
{
	CountArgs();	//0个
	CountArgs(1);	//1个
	CountArgs(1, string("ABCD"));	//2个
	CountArgs(1, string("ABCD"), vector<int>(10));	//3个

	return 0;
}

void ShowList()
{
	cout << endl;
	cout << "End of recursion" << endl;
}

template<class T, class ...Args>
void ShowList(T x, Args...args)
{
	cout << x << " ";
	//递归调用
	ShowList(args...);
}

template<class ...Args>
void PrintArgs(Args...args)
{
	//展开函数参数包
	ShowList(args...);
}

int main()
{
	PrintArgs(1, 2, 5, 'A', "hello");
	return 0;
}

template<class ...Args>
void PrintArgs(Args...args)
{
	(..., (cout << args << " "));	//左折叠
	cout << endl;
}

int main() {
	PrintArgs(1, 2.5, "Hello", 'A');
	return 0;
}

//用于存放pair的数组
vector<pair<string, int>> v;

//传统方法
v.push_back(make_pair("hello", 1));
v.push_back({ "world", 2 });

//emplace系列
v.emplace_back("happy", 3);

int main() {
    array<int, 4> arr = {1, 2, 3, 4};
    for (int n : arr) {
        cout << n << " ";
    }
    return 0;
}

int main() {
    forward_list<int> flist = {1, 2, 3};
    flist.push_front(0);  // 添加到头部
    for (int n : flist) {
       cout << n << " ";
    }
    return 0;
}

int main() {
   tuple<int, string, double> t(1, "Hello", 3.14);

    cout << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
    return 0;
}

class MyClass
{
public:
	MyClass(vector<int> v = vector<int>())
		:data(v)
	{}

	//移动构造
	MyClass(MyClass&& mycl) noexcept
		:data(move(mycl.data))
	{
		cout << "Move Constructor Called" << endl;
	}

	//移动赋值
	MyClass& operator=(MyClass&& mycl) noexcept
	{
		if (this != &mycl)
		{
			data = move(mycl.data);
			cout << "Move Assignment Operator Called" << endl;
		}
		return *this;
	}

	void show()
	{
		for (auto e : data)
		{
			cout << e << " ";
		}
		cout << endl;
	}

private:
	vector<int> data;
};

int main()
{
	//转移匿名对象的资源
	MyClass mycl1 = move(MyClass({ 1,2,3,4 }));
	mycl1.show();

	//转移mycl2的资源到mycl3
	MyClass mycl2({ 1,2,3,4 });
	MyClass mycl3;
	mycl3 = move(mycl2);
	mycl2.show();
	mycl3.show();
}

class MyClass {
public:
    MyClass() = default;  // 使用默认构造函数
    MyClass(const MyClass&) = default;  // 使用默认拷贝构造函数
};

class MyClass {
public:
    MyClass() = default;
    MyClass(const MyClass&) = delete;  // 禁止拷贝构造
};

class Base {
public:
    virtual void func() final {}  // 禁止进一步重写
};

class Derived : public Base {
    // void func() override {}  // 编译错误
};

class Base {
public:
    virtual void func() {}
};

class Derived : public Base {
public:
    void func() override {  // 确保是重写基类函数
        //...
    }
};

[capture](parameters) -> return_type { function_body }

	int main()
{
	auto hello = []()->void {
		cout << "hello world" << endl;
		};

	hello();
	return 0;
}

int main()
{
	auto add = [](int x, int y) {
		return x + y;
		};

	cout << add(2, 3) << endl;
}

int x = 10, y = 20, z = 30;

//按值捕获x，y，但是捕获而来的变量默认是加了const修饰的，如果想要修改需要加mutable
//因为是按值捕获是一种拷贝，在lambda里修改了捕获而来的变量也不会传递到外部
auto sum1 = [x, y]() mutable { x = 10; return x + y; };			

//按引用捕获x，y，对x，y的修改可以传递到外部
auto sum2 = [&x, &y]() { return x + y; };		

//按值捕获所有外部变量x、y、z
auto sum3 = [=]() { return x + y + z; };		

//按引用捕获所有外部变量x、y、z
auto sum4 = [&]() { return x + y + z; };		

//按值捕获所有外部变量，但按引用捕获z
auto sum5 = [=, &z]() { return x + y + z; };	

//按引用捕获所有外部变量，但按值捕获z
auto sum6 = [&, z]() { return x + y + z; };		

template <class Ret, class... Args>
class function<Ret(Args...)>;

int add(int x, int y)
{
	return x + y;
}

struct divide
{
	double operator()(double x, double y)
	{
		return x / y;
	}
};

class MyClass
{
public:
	int subtract(int x, int y) const
	{
		return x - y;
	}

	static void Print()
	{
		cout << "hello world" << endl;
	}
};

int main()
{
	//包装普通函数
	function<int(int, int)> addfunc = add;
	cout << addfunc(2, 3) << endl;		//输出5

	//包装lambda表达式
	function<int(int, int)> mumultiplyfunc = [](int x, int y) {
		return x * y;
		};
	cout << mumultiplyfunc(3, 4) << endl;	//输出12

	//包装仿函数
	function<double(double, double)> dividefunc = divide();
	cout << dividefunc(6, 3) << endl;	//输出2

	//包装成员函数，成员函数要指定类域并且加&才能取地址
	//还要注意隐式this指针的问题，传地址或者对象都可以
	function<int(MyClass*, int, int)> subtractfunc = &MyClass::subtract;
	MyClass mycl;
	cout << subtractfunc(&mycl, 7, 4) << endl;	//输出3

	//包装静态成员函数，静态成员函数没有this指针
	function<void()> Printfunc = &MyClass::Print;
	Printfunc();	//打印helloworld

	return 0;
}

class Solution {
public:
    
    
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for(auto e : tokens)
        {
           if(e != "+" && e != "-" && e != "*" && e != "/") st.push(stoi(e));
           
           else if(!st.empty())
           {
            int x = st.top();
            st.pop();
            int y = st.top();
            st.pop();
            switch(e[0])
            {
                case '+':
                    st.push(x + y); break;
                case '-':
                    st.push(y - x); break;
                case '*':
                    st.push(x * y); break;
                case '/':
                    st.push(y / x); break;

            }
           }
        }

        int ret = st.top();
        st.pop();
        return ret;
    }
};

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
		//function作为map的映射可调⽤对象的类型       
        map<string, function<int(int, int)>> FuncMap = {
            {"+", [](int x, int y){ return x + y; }},
            {"-", [](int x, int y){ return x - y; }},
            {"*", [](int x, int y){ return x * y; }},
            {"/", [](int x, int y){ return x / y; }},
        };

        stack<int> st;
        for(auto& str : tokens)
        {
            if(FuncMap.count(str))
            {
                int right = st.top();
                st.pop();
                int left = st.top();
                st.pop();
                int ret = FuncMap[str](left, right);
                st.push(ret);
            }
            else
            {
                st.push(stoi(str));
            }
        }
        return st.top();
    }
};

#include <functional>

auto new_func = std::bind(func, arg1, arg2, ...);

void print(int a, int b)
{
	cout << "a: " << a << "，b：" << b << endl;
}

class MyClass {
public:
	void display(int value) {
		cout << "Value: " << value << endl;
	}
};

struct Functor
{
	void operator()(int x, int y)
	{
		cout << "x - y = " << x - y << endl;
	}
};

int main()
{
	//绑定普通函数
	auto bound_func = bind(print, 10, placeholders::_1);
	bound_func(20);		

	//绑定lambda表达式
	auto add = bind([](int x, int y) { return x + y; }, 10, placeholders::_1);
	cout << "add："<< add(30) << endl;

	//绑定成员函数
	auto b_display = bind(&MyClass::display, MyClass(), placeholders::_1);
	b_display(20);

	//绑定仿函数
	auto b_subtract = bind(Functor(), 100, placeholders::_1);
	b_subtract(50);

	return 0;
}