【C++】C++11常见特性

🌇个人主页：平凡的小苏
📚学习格言：命运给你一个低的起点，是想看你精彩的翻盘，而不是让你自甘堕落，脚下的路虽然难走，但我还能走，比起向阳而生，我更想尝试逆风翻盘。
🛸C++专栏：C++内功修炼基地
> 家人们更新不易，你们的👍点赞👍和⭐关注⭐真的对我真重要，各位路过的友友麻烦多多点赞关注。欢迎你们的私信提问，感谢你们的转发！关注我，关注我，关注我，你们将会看到更多的优质内容！！

在这里插入图片描述

一、c++11介绍

C++98 / 03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98 / 03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习。

二、列表初始化

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

示例:

struct A
{
	int _x;
	int _y;
};
int main()
{
	int arr1[] = { 1, 2, 3, 4, 5 };
	int arr2[5] = { 0 };
	A a = { 1, 2 };
	return 0;
}

C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

示例：

struct A
{
	int _x;
	int _y;
};
int main()
{
	int n1 = 1;
	int n2{ 2 };
	int arr1[]{ 1, 2, 3, 4, 5 };
	int arr2[5]{ 0 };
	A a{ 1, 2 };
	// C++11中列表初始化也可以适用于new表达式中
	int* pa = new int[4]{ 0 };
	return 0;
}

创建对象时也可以使用列表初始化方式调用构造函数初始化

class Date
{
    public:
    Date(int year, int month, int day)
        :_year(year)
            ,_month(month)
            ,_day(day)
        {
            cout << "Date(int year, int month, int day)" << endl;
        }
    private:
    int _year;
    int _month;
    int _day;
};
int main()
{
    Date d1(2022, 1, 1); // old style
    // C++11支持的列表初始化，这里会调用构造函数初始化
    Date d2{ 2022, 1, 2 };
    Date d3 = { 2022, 1, 3 };
    return 0;
}

2.1、initializer_list

initializer_list使用场景:

std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值。

示例：

int main()
{
    vector<int> v = { 1,2,3,4 };
    list<int> lt = { 1,2 };
    // 这里{"sort", "排序"}会先初始化构造一个pair对象
    map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };
    // 使用大括号对容器赋值
    v = {10, 20, 30};
    return 0;
}

三、声明类型

3.1、auto

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

在这里插入图片描述

3.2、decltype

关键字decltype将变量的类型声明为表达式指定的类型。

// decltype的一些使用使用场景
template<class T1, class T2>
    void F(T1 t1, T2 t2)
{
    decltype(t1 * t2) ret;
    cout << typeid(ret).name() << endl;
}
int main()
{
    const int x = 1;
    double y = 2.2;
    decltype(x * y) ret; // ret的类型是double
    decltype(&x) p;      // p的类型是int*
    cout << typeid(ret).name() << endl;
    cout << typeid(p).name() << endl;
    F(1, 'a');
    return 0;
}

在这里插入图片描述

四、右值引用和移动语义

4.1、新增的两个默认成员函数

C++11新增了两个类的默认成员函数：移动构造函数和移动赋值运算符重载。

如果你没有手动实现移动构造函数，并且析构函数、拷贝构造、赋值运算符重载均没有手动实现，编译器就会帮你生成一个默认的移动构造函数。默认生成的移动构造函数，对于内置类型进行按字节的值拷贝，对于自定义类型，将会去调用它的移动构造函数，如果这个内置类型并没有移动构造函数，则编译器去调用它的拷贝构造函数。

如果你没有手动实现移动赋值运算符重载，并且析构函数、拷贝构造、赋值运算符重载均没有手动实现，编译器就会帮你生成一个默认的移动赋值运算符重载。默认生成的移动赋值运算符重载，对于内置类型进行按字节的值拷贝，对于自定义类型，将会去调用它的移动赋值运算符重载，如果这个内置类型并没有移动赋值运算符重载，则编译器去调用它的赋值运算符重载。

4.2、强制与禁止生成默认成员函数的关键字

1、default

Person(Person&& p)=default;//让编译器强制生成移动构造

Person(Person&& p)=default;//让编译器强制生成移动构造

2、delete

例如现在需要禁用某个类的拷贝构造函数，C++98的玩法是将这个类的拷贝构造函数加上私有权限，并且只声明不实现，就可以在类的内部和外部禁用掉拷贝构造。

C++11使用delete关键字禁止生成某个默认构造函数：

A(const A& a)=delete;//防拷贝

4.3、左值和右值

1、左值和左值引用

变量和解引用得到的变量是左值，我们可以获取它的地址，左值可以出现赋值符号的左边和右边，右值只能出现在赋值符号的右边。

int main()
{
    // 以下的a、k、c、*p都是左值
    int* a = new int(0);
    int k = 1;
    const int c = 2;
    // 以下几个是对上面左值的左值引用
    int*& tp = a;
    int& tb = k;
    const int& rc = c;
    int& p_val = *a;
    return 0;
}

2、右值和右值引用

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。C++11中将右值划分成纯右值（内置类型表达式的值）和将亡值（自定义类型的表达式的值）

int main()
{
    double x = 1.1, y = 2.2;
    // 以下几个都是常见的右值
    10;
    x + y;
    fmin(x, y);
    // 以下几个都是对右值的右值引用
    int&& rr1 = 10;
    double&& rr2 = x + y;
    double&& rr3 = fmin(x, y);
    // 这里编译会报错：error C2106: “=”: 左操作数必须为左值
    10 = 1;
    x + y = 1;
    fmin(x, y) = 1;
    return 0;
}

总结：

右值引用只能引用右值，不能引用左值。

但是右值引用可以引用move以后的左值。

int main()
{
     // 右值引用只能右值，不能引用左值。
     int&& r1 = 10;
     
     // error C2440: “初始化”: 无法从“int”转换为“int &&”
     // message : 无法将左值绑定到右值引用
     int a = 10;
     int&& r2 = a;
     // 右值引用可以引用move以后的左值
     int&& r3 = std::move(a);
     return 0;
}

4.4、右值的别名是左值

右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1，这里的rr1是左值。如果不想rr1被修改，可以用const int&& rr1 去引用。（这个特性在移动赋值中也可以体现，移动赋值参数是右值引用，通过交换这个右值引用的对象完成赋值的目的）

int main()
{
     double x = 1.1, y = 2.2;
     int&& rr1 = 10;//rr1其实是一个左值
     const double&& rr2 = x + y;
     rr1 = 20;
     rr2 = 5.5;//报错  
     return 0;
}

因为右值引用的形参是左值，层层传递时，需要将这个形参move为右值：

void push_back(T&& x)//x为左值
{
	insert(end(),move(x));//需要用move转换为右值，不然会去调用左值版本的insert
}    
iterator insert(interator pos,T&& x)//x为左值
{
	node* newnode=new node(move(x));//需要用move转换为右值，不然会去调用左值版本的node构造函数
}
list_node(T&& x)//x是左值
	：_next(nullptr)
    ,_prev(nullptr)
    ,_data(move(x))//需要用move转换为右值，不然会去调用左值版本的T _data的构造函数
{}

不过这样写的话需要左值写一份，右值的写一份，代码重复了。更推荐下面讲的完美转发的写法。

4.5、模板中的万能引用

#include <iostream>

using namespace std;
// decltype的一些使用使用场景
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;
}

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发

在这里插入图片描述

注意：这里不使用完美转发都是左值引用，下面看使用完美转发

4.6、完美转发

std::forward 完美转发在传参的过程中保留对象原生类型属性，当然完美转发也是需要在模板的环境下才能生效，如果不是模板，T&& t同样会被识别成右值引用。

万能引用和完美转发必须保证传参时，才实例化对象，如果传参前模板已经被实例化了，将构不成万能引用和完美转发。

在这里插入图片描述

4.7左值引用和右值引用使用场景

左值引用使用场景

左值引用在函数传参、函数传返回值（必须保证返回值出了作用域还在）时使用可以减少拷贝。如果函数的返回值出了作用域会被销毁，则不能使用左值引用来减少拷贝（销毁后引用的对象非法），这个时候就需要使用右值引用了。C++在没有右值引用的时候，可以采用输出型参数的方法解决传值返回多次拷贝的问题。

右值引用场景

使用场景一：深拷贝的类中的传值返回的拷贝问题

C++11通过右值引用实现的移动构造和移动赋值解决值返回多次拷贝的问题，提升了效率：

class string
{
public:
    //拷贝构造
    string(const string& s)//传入的s是左值，需要老老实实构造
    {
        string tmp(s.c_str());
        swap(tmp);
    }
    //移动构造
    string(string&& s)//传入的s是将亡值，可以换走s的成员
    {
        swap(s);//将s的成员直接换给*this，s消亡后自动调用析构函数
    }
	// 赋值重载
    string& operator=(const string& s)
    {
        string tmp(s);
        swap(tmp);
        return *this;
    }
	// 移动赋值
    string& operator=(string&& s)
    {
        swap(s);
        return *this;
    }
private:
    char* _str = nullptr;
    size_t _capacity = 0;
    size_t _size = 0;
};

对于深拷贝的类，C++11使用右值引用实现的移动构造和移动赋值，在需要拷贝的场景中，可以直接转移将亡值的资源。如下图，虽然to_string是传值返回，但是str被编译器识别为将亡值，编译器会调用移动构造一步到位的对ret1进行构造，代价很低。
在这里插入图片描述

使用场景二：插入右值数据，也可以减少拷贝

int main()
{
	list<string> it;
	string s1("1111");
	it.push_back(s1);//左值，深拷贝
	it.push_back(string("2222"));//右值，直接移动构造转移右值资源
	it.push_back("3333");//右值，直接移动构造转移右值资源
	return 0;
}

五、lamaba表达式

5.1、lamaba表达式介绍

lambda表达式的作用是创建一个匿名函数，可以在需要函数对象的地方使用。它通常用于函数式编程中，可以避免定义一个命名函数，从而简化代码。使用lambda表达式可以在代码中直接定义一个函数对象，并将其作为参数传递给其他函数或算法，或者直接调用它。lambda表达式可以捕获其所在作用域的变量，并将其作为函数对象的成员变量，从而实现闭包功能。使用lambda表达式可以使代码更加简洁、清晰，提高程序的可读性和可维护性。

//lambda本质是一个匿名函数，其表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }

[capture - list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用，必须写；
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略；
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)；
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导；
{
statement
}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量，必须写。使用lamaba表达式进行排序

在这里插入图片描述

5.2、lamaba表达式的捕捉列表、mutable

这是一段lambda表达式对外部参数b的捕获：

int main()
{
	int a = 0, b = 1;
	auto add = [b](int a) {return a + b; };//把上文的b捕捉到lambda表达式中
	return 0;
}

捕捉的真的是b吗？其实捕捉的仅仅是带const属性的b的拷贝罢了。可使用mutable取消拷贝对象的const属性：

auto add = [b](int a) mutable{return a + b; };//取消b的const属性

现在我想用lambda表达式交换一下外部两个变量的值，那么就需要在捕捉列表中引用这两个变量：

int main()
{
	int a = 0, b = 1;
	auto swap = [&a, &b]()//这里是引用的方式捕捉，不是取地址
	{
		int tmp = a;
		a = b;
		b = tmp;
	};
	swap();
	std::cout << a << " " << b << std::endl;
	return 0;
}

上面的lambda表达式的捕捉列表中的&a和&b其实是a和b的引用，不要理解成取地址。因为捕捉只有两种方式：传值捕捉和传引用捕捉。静态变量和全局变量无法捕捉，但可以在lambda表达式中直接使用并自带引用属性。

5.3、捕获列表说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。

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

5.4、lambda的底层就是仿函数

在这里插入图片描述

六、容器中新增的emplace系列

6.1、可变参数模板

c++11的新增特性可变参数模板能够让使用者创建可以接受可变参数的函数模板和类模板。

下面就是一个基本可变参数的函数模板

// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特点，也是最大的难点，即如何展开可变模版参数。由于语法不支持使用args[i]这样方式获取可变参数，所以我们的用一些奇招来一一获取参数包的值。

// 递归终止函数
void ShowList()
{
	cout << endl;
}

template<class T, class ...Args>
void ShowList(T value, Args ...args)//语法规定在template中，三个点在args的前面
{
	cout << value << " ";
	ShowList(args...);//语法规定，传参时三个点在args的后面
}
int main()
{
	ShowList();
	ShowList(1);
	ShowList(1,std::string("left"));
	return 0;
}

解析：

ShowList(1,’A’,std::string(“left”))进行调用

首次将调用模板函数ShowList，

val是1，参数包还剩下一个参数string(“left”)

函数内部调用ShowList，并传递参数包

再次调用模板函数ShowList

val是string(“left”)，并传递参数包

根据匹配规则，将调用无参的函数ShowList

流程结束

方式二:逗号表达式展开参数包(方式不能解析0个参数的参数包)

这种展开参数包的方式，不需要通过递归终止函数，是直接在expand函数体中展开的, printarg不是一个递归终止函数，只是一个处理参数包中每一个参数的函数。这种就地展开参数包的方式实现的关键是逗号表达式。我们知道逗号表达式会按顺序执行逗号前面的表达式。

expand函数中的逗号表达式：(printarg(args), 0)，也是按照这个执行顺序，先执行printarg(args)，再得到逗号表达式的结果0。同时还用到了C++11的另外一个特性——初始化列表，通过初始化列表来初始化一个变长数组, {(printarg(args), 0)…}将会展开成((printarg(arg1),0), （printarg(arg2),0), (printarg(arg3),0), etc… )，最终会创建一个元素值都为0的数组int arr[sizeof…(Args)]。由于是逗号表达式，在创建数组的过程中会先执行逗号表达式前面的部分printarg(args)打印出参数，也就是说在构造int数组的过程中就将参数包展开了，这个数组的目的纯粹是为了在数组构造的过程展开参数包.

template <class T>
int PrintArgs(T t)
{
	std::cout << t << " ";
	return 0;
}
template <class ...Args>
void ShowList(Args... args)
{
	//int arr[] = { (PrintArgs(args),0)... };//逗号表达式
    //参数包有几个值，数组就开多大，函数就被调用几次，函数调用时依次展开参数包中内容
	int arr[] = { PrintArgs(args)... };
	std::cout << std::endl;
}
int main()
{
	//ShowList();
	ShowList(1);
	ShowList(1,std::string("xxxxx"));
	return 0;
}

6.2、emplace系列的优势

int main()
{
	std::list<int> list1;
	list1.push_back(1);
	list1.emplace_back(2);
	list1.emplace_back();//会插入0
    
	std::list< std::pair<int, char> > mylist;
	mylist.push_back(make_pair(1, 'a'));  // 构造+拷贝构造（如果是右值就是构造+移动构造）
	//mylist.push_back(1, 'a');//push_back不允许传两个参数
    mylist.push_back({ 40, "sort" });//列表初始化
	mylist.emplace_back(1, 'a'); // empalce支持多参数，直接构造
	return 0;
}

int main()
{
	pair<int, std::string> kv(20, "sort");
	std::list< std::pair<int, std::string> > mylist;
 
	mylist.push_back(kv); // 左值
	mylist.push_back(make_pair(30, "sort")); // 右值
	mylist.push_back({ 40, "sort" }); // 右值
 
    mylist.emplace_back(kv); // 左值
	mylist.emplace_back(make_pair(20, "sort")); // 右值（简化为一次构造）
	mylist.emplace_back(10, "sort"); // 构造pair参数包（简化为一次构造）
 
	return 0;
}

无论是push_back还是emplace_back,尽量不要使用左值进行插入操作，插入左值必发生拷贝构造。

push_back方法：
对于非深拷贝类型，push_back会调用构造+拷贝构造，如果元素是深拷贝的对象，就是构造+移动构造。

emplace_back方法：
emplace_back方法会在容器尾部直接构造一个新元素，它的参数是元素的构造函数参数列表。emplace系列能将参数包展开，将过程简化为一次构造。

所以从效率上来说，emplace系列会高效一点.如果一个深拷贝的类没有实现移动构造，这个时候push_back的效率将远不如emplace_back。

七、包装器

1、function包装器

1.1、包装器的意义

function包装器，也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

function的作用是对各种可调用对象进行类型统一。

在这里插入图片描述

函数模板Use被实例化了三份，使用包装器可以解决这一问题。

在这里插入图片描述

1.2、包装器的使用

在这里插入图片描述

int f(int a, int b)
{
	return a + b;
}
struct Functor
{
public:
	int operator() (int a, int b)
	{
		return a + b;
	}
};
class Plus
{
public:
	static int plusi(int a, int b)
	{
		return a + b;
	}
	double plusd(double a, double b)
	{
		return a + b;
	}
};
int main()
{
	// 函数名(函数指针)的三种写法
	function<int(int, int)> func1 = f;
	cout << func1(1, 2) << endl;
 
	function<int(int, int)> func2;
	func2 = f;
	cout << func2(1, 2) << endl;
 
	function<int(int, int)> func3(f);
	cout << func3(1, 2) << endl;
	// 函数对象
	function<int(int, int)> func4 = Functor();
	cout << func4(1, 2) << endl;
	// lamber表达式
	function<int(int, int)> func5 = [](const int a, const int b)
	{return a + b; };
	cout << func5(1, 2) << endl;
 
	// 类的成员函数，包装器的静态成员函数可以不加&取地址，普通函数需要加&取地址，建议一律加上
	function<int(int, int)> func6 = &Plus::plusi;//类静态成员函数指针，&可加可不加
	cout << func6(1, 2) << endl;
	function<double(Plus, double, double)> func7 = &Plus::plusd;//类成员函数指针，&必须加，并且需要传类名
	cout << func7(Plus(), 1.1, 2.2) << endl;//调用的时候得传对象，不是传&Plus的地址
	//function包装带捕获的lambda表达式
	Plus plus;
	function<double(double, double)> func8 = [&plus](double x, double y)->double {return plus.plusd(x, y); };
	cout << func8(1.1, 2.2) << endl;
	return 0;
}

2.bind

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。可以用于固定绑定参数和调整参数的顺序。

// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2) 
template <class Ret, class Fn, class... Args>
/* unspecified */ bind (Fn&& fn, Args&&... args);

#include <iostream>
#include<map>
#include<functional>
using namespace std;

int Plus(int a, int b)
{
	return a + b;
}
int SubFunc(int a, int b)
{
	return a - b;
}
class Sub
{
public:
	int sub(int a, int b)
	{
		return a - b;
	}
};
int main()
{
	//表示绑定函数Plus 参数分别由调用 func1 的第一，二个参数指定
	::function<int(int, int)> func1 = ::bind(Plus, placeholders::_1,placeholders::_2);
	cout << func1(1, 2) << endl;
	function<int(int, int)> func2 = bind(SubFunc, placeholders::_1, placeholders::_2);
	cout << func2(1, 2) << endl;
	//调整参数的顺序
	function<int(int, int)> func3 = bind(SubFunc, placeholders::_2, placeholders::_1);
	cout << func3(1, 2) << endl;
	function<bool(int, int)> gt = bind( less<int>(), placeholders::_2, placeholders::_1);//降序
	cout << gt(1, 2) << endl;
	//固定绑定参数
	function<int(Sub, int, int)> func4 = &Sub::sub;
	cout << func4(Sub(),1, 2) << endl;//这样写总是要传入一个类匿名对象进行打印
	function<int(int, int)> func5 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);//固定sub()
	cout << func5(1, 2) << endl; 
	return 0;
}