1 列表初始化
1.1 内置类型的列表初始化
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};
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;
}
1.2 自定义类型的列表初始化
多个对象本身不支持列表初始化，多个对象想要支持列表初始化，需给该类(模板类)添加一个带有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;
};
Vector<int> v2{ 1,2,3 };
Vector<int> v3 = { 1 };
2 decltype变量类型推导
decltype():根据表达式的实际类型推演出定义变量时所用的类型。
int fun(int a)
{
return a;
}
void test01()
{
auto a = 10;
int b = 1;
int c = 2;
decltype(b + c) d;
cout << typeid(d).name() << endl;
cout << typeid(decltype(fun(a))).name() << endl;
cout << typeid(decltype(fun)).name() << endl;
}
3 默认成员控制
3.1 显示缺省函数
在C++11中，可以在默认函数定义或者声明时加上**=default**，从而显式的指示编译器生成该函数的默认版本，用=default修饰的函数称为显式缺省函数。
class A {
public:
A(int a): _a(a)
{}
A() = default;
A(const 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; }
3.2 删除默认函数
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且不给定义，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上**=delete**即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。
注意：避免删除函数和explicit一起使
class B
{
public:
B(){}
B(const B&) = delete;
B& operator=(const B&) = delete;
};
void test()
{
B b;
}
4 右值引用
4.1 左值与右值
void test()
{
int a = 10;
int b = a;
int* pa = &a;
b = fun(1);
b = fun(a);
}
4.2 左值引用与右值引用
void test()
{
int a = 10;
int& ra = a;
const int& ri = 10;
const int& ri2 = fun(a);
int&& rri = 10;
int&& tt = fun(a);
}
4.3 移动语义
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; }
strRet在按照值返回时，必须创建一个临时对象，临时对象创建好之后，strRet就被销毁了，最后使用返回的临时对象构造s3，s3构造好之后，临时对象就被销毁了。仔细观察会发现：strRet、临时对象、s3每个对象创建后，都有自己独立的空间，而空间中存放内容也都相同，相当于创建了三个内容完全相同的对象，对于空间是一种浪费，程序的效率也会降低，而且临时对象确实作用不是很大。
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(String&& s)
:_str(s._str)
{
s._str = nullptr;
cout << "String(String&& s)" << endl;
}
String& operator=(String&& s)
{
if (this != &s)
{
_str = s._str;
s._str = nullptr;
}
}
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");
cout << "copy" << endl;
String s3(s1 + s2);
String s4(s2);
cout << "---" << endl;
s4=s1+s2;
cout << "-----" << endl;
}
因为strRet对象的生命周期在创建好临时对象后就结束了，即将亡值，C++11认为其为右值，在用strRet构造临时对象时，就会采用移动构造，即将strRet中资源转移到临时对象中。而临时对象也是右值，因此在用临时对象构造s3时，也采用移动构造，将临时对象中资源转移到s3中，整个过程，只需要创建一块堆内存即可，既省了空间，又大大提高程序运行的效率。
4.4 右值引用引用左值
int main()
{
String s1("hello");
String s2("world");
cout << "copy" << endl;
String s3(s1 + s2);
String s4(s2);
cout << "---" << endl;
s4=s1+s2;
cout << "-----" << endl;
String&& rs = std::move(s3);
String s6(move(s3));
return 0;
}
正确使用move的例子
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; }
4.5 完美转发
完美转发是指在函数模板中，完全依照模板的参数的类型，将参数传递给函数模板中调用的另外一个函数。
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);
int a;
PerfectForward(a);
PerfectForward(std::move(a));
const int b = 8;
PerfectForward(b);
PerfectForward(std::move(b));
return 0;
}
5 lambda表达式
5.1 什么是仿函数
struct Greater
{
bool operator()(const T& a, const T& b)
{
return a > b;
}
};
struct MyPlus {
int operator()(const int& a, const int& b) const {
return a + b;
}
};
void test01()
{
Greater<int> g;
bool ret=g.operator()(10, 20);
ret = g(10, 20);
}
void test02()
{
MyPlus a;
cout << MyPlus()(1, 2) << endl;
cout << a.operator()(1, 2) << endl;
cout << a(1, 2) << endl;
return 0;
}
5.2 为什么要写lambda表达式
在C++98中，如果想要对一个数据集合中的元素进行排序，可以使用std::sort方法。
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; }
随着C++语法的发展，人们开始觉得上面的写法太复杂了，每次为了实现一algorithm算法， 都要重新去写一个类，如果每次比较的逻辑不一样，还要去实现多个类，特别是相同类的命名，这些都给编程者带来了极大的不便。因此，在C11语法中出现了Lambda表达式。
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; }
上述代码就是使用C++11中的lambda表达式来解决，可以看出lamb表达式实际是一个匿名函数。
5.3 lambda表达式语法
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }
- lambda表达式各部分说明
[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
注意： 在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
void test()
{
int a = 10;
int b = 20;
[a, b] {return a + b; };
[a, b](int c, int d, int e) {return a + b + c; };
[a, b](int c)->int {return a + b + c; };
[a, b](int c)mutable->int {a = 100; b = 200; return a; };
[] {};
[a, b] {return a + b; };
[a, b]()mutable {return a + b; };
auto f = [a, b](int c) {return a + b + c; };
int e = f(10);
auto f2 = [=] {return a + b + e; };
auto f3 = [&]() {a = 1; b = 1000; };
auto f4 = [&, a]() {return a + b; };
auto f5 = [=, &a, &e]() {return a + b + e; };
struct A
{
void fun(int a)
{
auto f = [this]() {return _a; };
}
int _a;
};
}
5.4 lambda表达式的性质
typedef int(*ptr)(int);
void test()
{
auto f = [](int a) {return a; };
auto f2 = [](int a) {return a; };
auto copy(f);
ptr f4 = f;
}
struct Sum
{
int operator()(int a, int b)
{
return a + b;
}
};
void test()
{
auto f = [](int a, int b) {return a + b; };
int sum = f(10, 20);
Sum s;
s(10, 20);
}
5.5 线程库
void fun(int a)
{
cout << "fun(int a)" << endl;
}
struct Fun
{
void operator()()
{
cout << "Fun operator()" << endl;
}
};
void test()
{
thread t();
thread t1(fun, 10);
t1.joinable();
t1.join();
Fun f;
thread t2(f);
t2.join();
thread t3([] {cout << "lambda" << endl; });
t3.join();
}
5.6 线程函数参数
class A
{
public:
void fun1(int a, int b)
{
cout << "fun1(int,int)" <<" "<< a <<" "<< b << endl;
}
};
void fun(int& a)
{
a += 10;
}
void fun1(int* atr)
{
*atr += 10;
}
void test()
{
A a;
thread t1(&A::fun1, &a,10, 20);
t1.join();
int a3 = 1;
thread t3(fun1, &a3);
cout << a3 << endl;
t3.join();
thread t4(fun, ref(a3));
cout << a3 << endl;
t4.join();
}
5.7 join与detach
启动了一个线程后，当这个线程结束的时候，如何去回收线程所使用的资源呢？thread库给我们两种选择：
join()方式
join()：主线程被阻塞，当新线程终止时，join()会清理相关的线程资源，然后返回，主线程再继续向下执行，然后销毁线程对象。由于join()清理了线程的相关资源，thread对象与已销毁的线程就没有关系了，因此一个线程对象只能使用一次join()，否则程序会崩溃。
detach()方式
detach()：该函数被调用后，新线程与线程对象分离，不再被线程对象所表达，就不能通过线程对象控制线程了，新线程会在后台运行，其所有权和控制权将会交给c++运行库。同时，C++运行库保证，当线程退出时，其相关资源的能够正确的回收。
就像是你和你女朋友分手，那之后你们就不会再有联系（交互）了，而她的之后消费的各种资源也就不需要你去埋单了（清理资源）。
****detach()函数一般在线程对象创建好之后就调用，因为如果不是jion()等待方式结束，那么线程对象可能会在新线程结束之前被销毁掉而导致程序崩溃。因为std::thread的析构函数中，如果线程的状态是jionable，std::terminate将会被调用，而terminate()函数直接会终止程序。
void fun2(int n)
{
for (int i= 0; i < n; i++)
{
cout << i << " ";
}
cout << "fun2..." << endl;
}
void test()
{
thread t1(fun2, 1000);
t1.detach();
cout << "test" << endl;
}
class ThreadManger
{
public:
ThreadManger(thread& t)
:_t(t)
{}
~ThreadManger()
{
if (_t.joinable())
{
_t.join();
}
}
private:
thread& _t;
};
void test()
{
thread t1([] {});
ThreadManger tm(t1);
vector<int> v;
v.at(3) = 10;
t1.join();
}
int main()
{
try
{
test();
}
catch (exception& e)
{
cout << e.what() << endl;
}
return 0;
}
5.8 原子操作
多线程最主要的问题是共享数据带来的问题(即线程安全)。如果共享数据都是只读的，那么没问题，因为只读操作不会影响到数据，更不会涉及对数据的修改，所以所有线程都会获得同样的数据。但是，当一个或多个线程要修改共享数据时，就会产生很多潜在的麻烦。比如：
#include <iostream>
using namespace std;
#include <thread>
unsigned long sum = 0L;
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, 10000000);
thread t2(fun, 10000000);
t1.join();
t2.join();
cout << "After joining,sum = " << sum << std::endl;
return 0; }
C++98中传统的解决方式：可以对共享修改的数据可以加锁保护。
#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; }
虽然加锁可以解决，但是加锁有一个缺陷就是：只要一个线程在对sum++时，其他线程就会被阻塞，会影响程序运行的效率，而且锁如果控制不好，还容易造成死锁。
因此C++11中引入了原子操作。所谓原子操作：即不可被中断的一个或一系列操作，C++11引入的原子操作类型，使得线程间数据的同步变得非常高效。
atomic<int> sum(0);
void fun(int n)
{
for (int i = 0; i < n; i++)
{
sum++;
}
}
void test()
{
int n;
cin >> n;
thread t1(fun, n);
thread t2(fun, n);
t1.join();
t2.join();
cout << sum << endl;
}
5.9 lock_guard
mutex mtx;
template<class Mtx>
class LockGuard
{
public:
LockGuard(Mtx& mtx)
:_mtx(mtx)
{
mtx.lock();
}
~LockGuard()
{
mtx.unlock();
}
LockGuard& operator=(const LockGuard&) = delete;
LockGuard(const LockGuard&) = delete;
private:
Mtx& _mtx;
};
void fun1()
{
LockGuard<mutex> lg(mtx);;
cout << "fun1()" << endl;
int n;
cin >> n;
if (n == 0)
return;
mtx.unlock();
}
void fun2()
{
LockGuard<mutex> lg(mtx);
mtx.lock();
cout << "fun2()" << endl;
mtx.unlock();
}
void test()
{
thread t1(fun1);
thread t2(fun2);
t1.join();
t2.join();
}
通过上述代码可以看到，lock_guard类模板主要是通过RAII的方式，对其管理的互斥量进行了封装，在需要加锁的地方，只需要用上述介绍的任意互斥体实例化一个lock_guard，调用构造函数成功上锁，出作用域前，lock_guard对象要被销毁，调用析构函数自动解锁，可以有效避免死锁问题。
|