# Uniform Initialization in c++ 11 by common syntax {}
```c++11
int i; //undefined value
int* p; //undefined value
int j{}; //initialized by 0
int* q{}; //initialized by nullptr
int values[] {1,2,3};
std::vector v {4, 5, 6};
```
# What's the Lambda
+ 函数对象 A lambda expression is a mechanism for specifying a function object.
+ 匿名函数
+ 功能集 A lambda is a definition of unctionality that can be defined inside statesments and expressions.
+ definition
+ [...] {...}
+ [...] (...) mutable throwSpec -> returnType {...}
+ !! mutable and throwSpec is optional
+ [&] 类似参数的引用传递，
+ [=] 类似参数的拷贝传递, 传递lambda作用域外的所有变量,以 const 形式
+ mutable 与[=]类似，但可以修改lambda 域外的变量
# How to use it
+ **use it as inline function**
+ use it as return type of a function
# other
+ you can use decltype to use the type of Lambda
+ you can use std::function<> class template get functional type
# example
```c++
[] { std::cout<<"hello Lambda";} //minimal definition
[] { std::cout<<"hello Lambda";} (); //call it directly
auto myFunction= [] { std::cout<<"hello Lambda";};
myFunction();
```
```c++
auto fun = [] (const std::string& s){
std::cout<<s;
};
fun("hello Lambda");
```
```c
[] { return 42;} //Is it ok?
[] () -> double {
return 42;
}
```
```c
int x=0;
int y=42;
auto ff=[x,&y]{
cout<<"x： "<< x <<endl;
cout<<"y: "<< y <<endl;
y++;
};
x=y=77;
ff();
ff();
cout<<"final y: "<< y <<endl;
```
```c
vector<int> v = {50, -10, 20, -30};
std::sort(v.begin(), v.end()); //the default sort { -30, -10, 20, 50 }
// sort by absolute value:
std::sort(v.begin(), v.end(), [](int a, int b) { return abs(a)<abs(b); }); // now v should be { -10, 20, -30, 50 }
```
# Smart Pointers
## shared_ptr
+ 共享指针，多个指针可同时指向一个对象，最后一个共享指针负责delete对象。
+ 注意： default deleter is "delete", Not "delete[]" (assuming object is createdy by new.)
+ 不支持隐式转换
+ you can use function make_shared() to handle this
+ 声明之后，再赋值要用 reset(), 不能直接用 =
+ use_count 可以返回其他指向相同对象的shared_ptr指针个数
### 自定义Deleter
```c++
shared_ptr<string> sp(new string("jane"),
[](string* p)){
cout<<"delete "<<*sp<<endl;
delete p;
}
);
```
### 处理数组
```c++
shared_ptr<int> sp(new int[10],
[](int* p)){
delete[] p;
}
);
```
```c++
shared_ptr<int> sp(new int[10],
default_delete<int[]>() //provided by unique_ptr
);
```
## unique_ptr
+ unique_ptr 指向的对象，具有排他性，这个对象和相关资源只能被unique_ptr管理，当指针不在指向这个对象的时候，这个对象就会被销毁，其资源也会被释放。
+ 可以有效防止因异常中断引起的内存泄漏
+ 有了unique_ptr, 甚至不用再写 delete 和 catch 语句
+ reset(), = nullptr
+ release(), bool()
+ Avoid 用一个对象初始化两个unique_ptr！ compile is pass， while fail run time.
+ use std::move() 可以在两个unique_ptr之间传递对象
### How to use
#### Source & Sink
+ source: use unique_ptr in function as return type
+ automatically called std::move() by compiler
+ sink: use unique_ptr in function as parameter type
+ should use std::move() to pass parameter
#### as class Members
Avoid resource leaks caused by exceptions thrown during the initialization of an object.
#### Dealing with Arrays
```c++
unique_ptr<string> up(new string[10]) //Note!! run time error
unique_ptr<string[]> up(new string[10]) //OK
cout<<*up; //error
cout<<up[0]; //OK
```
