C++11

C++11

1. 智能指针
看的是 STL里面的智能指针 , std::下面的. auto_ptr , unique_ptr , shared_ptr , weak_ptr.
C++ 可以控制堆区空间, 手动申请, 手动释放. 遗忘 , 没释放 , 后果, 内存泄露. 可不可以自动释放? --> 智能指针.
C++ 封装类, 就是对象, 生命周期结束时, 触发析构, 自然回收空间. 使用智能指针, 可以一定程度上方便编程 , 避免手动回收.
auto_ptr , unique_ptr , shared_ptr , weak_ptr.
auto_ptr C++98 标准中的, 其实有设计缺陷, 现在不常用 .

class AA
{
AA(const string s)
{
str= s;
cout<<"AA()"<<endl;
}
~AA()
{
cout<< "~AA()"<<endl;
}
void say()
{
cout<<str<<endl;
}
public:
string str;
private:
};

//初始化方法1
std::auto_ptr ap1(new AA(“using auto_ptr”)); //ap1 就是智能指针
{
ap1->say(); //对象生命结束, 指针回收对象是自动的.
}
cout<<"------------------"<<endl;
//初始化方法2 可以通过reset()方法
std::auto_ptr ap1;
{
//初始化指针指针 auto_ptr
ap1.reset( new AA(“using auto_ptr”));
ap1->say();
}
cout<<"------------------"<<endl;
//可以赋值
std::auto_ptr ap1(new AA(“using auto_ptr”)); //有可能 已经被unique_ptr取代了
std::auto_ptr ap2; // unique_ptr
{
ap1->say(); // ap2获取ap1的对象, ap1里面没对象,再调用就出问题.
ap2 = ap1; // ap2获取ap1的对象
}
std::unique_ptr up1( new AA(“using unique_ptr1”));
{
//unique_ptr 初始化
std::unique_ptr up2;
up2.reset( new AA(“using unique_ptr2”) ); //会释放原来空间
// make_unique<>()
up1->say();
//up2->say(); get方法 up1 和up1.get() 是一样的
up2.get()->say();
//不同的点 : unique_ptr 要求对象所属的智能指针必须唯一.
//不可以两个指针指向同一个对象
//std::unique_ptr up3 = up1; // 不可以
std::unique_ptr up3;
//把使用权交出去 必须显式的使用, 不会像auto_ptr 莫名的就把空间交出去
up3 = std::move(up1); //将up1对象 交给up3 , up1 就空了, 不要再用了
//up3 = up1; //赋值也是不可以的.
up3->say();
//up1->say(); //up1 空了, 不要再用了
}
// 不同的点: shared_ptr --> 引用计数 来控制对象的回收 , 引用计数归0 才回收
//想要回收 , 可以使用weak_ptr , 使用它 , 引用计数不加1
std::shared_ptr sp1( new AA(“using shared_ptr1”));
{
//shared_ptr 初始化
std::shared_ptr sp2;
sp2.reset( new AA(“using shared_ptr2”) ); //会释放原来空间
// make_unique<>()
// make_shared<>()
std::shared_ptr sp3;
sp3 = make_shared(“using shared_ptr3”);
sp1->say();
//sp2->say(); get方法 sp1 和sp1.get() 是一样的
sp2.get()->say();
sp3->say();
std::shared_ptr sp4;
sp4 = sp1; //指向同一个空间
sp4->say();
sp1->say(); //可以同时使用
cout<< “using count:”<<sp1.use_count() <<endl; //2
cout<< “using count:”<<sp1.use_count() <<endl;//1
}
class BBBB;
class AAAA
{
AAAA()
{
cout<<“AAAA()”<<endl;
}
~AAAA()
{
cout<<"~AAAA"<<endl;
}
shared_ptr spb;
public:
};
class BBBB
{
BBBB()
{
cout<<“BBBB()”<<endl;
}
~BBBB()
{
cout<<"~BBBB"<<endl;
}
shared_ptr spa;
//weak_ptr spa;
public:
};
shared_ptr pAA(new AAAA);
shared_ptr pBB(new BBBB);
pAA->spb = pBB; //spb改成 weak_ptr 引用计数不加1
pBB->spa = pAA;
cout<< “pAA using count:”<<pAA.use_count()<<endl;
cout<< “pBB using count:”<<pBB.use_count()<<endl;
{
}//没有回收

2. lamda表达式

//bool func( int a, int b)
//{
// return a>b;
//}
vector<int> vec;
 vec.push_back(10);
vec.push_back(1);
vec.push_back(9);
vec.push_back(3);
vec.push_back(7);
vec.push_back(4);
int val;
std::sort(vec.begin(),vec.end() , [ ](int a , int b){return a>b;} ); 

//lamda表达式的使用
// std::sort(vec.begin(),vec.end() , func );
C++ 有一种说法叫做万物皆可对象。函数可不可以是对象？可不可以在函数内部定义一个函数？
函数内部定义函数采用的方式就是lamda的表达式。
//先来说lamda表达式语法.
//auto func = [ ] ( ) mutable -> return type { 函数体 ; };
// 1.____ 2._____ 3._____ 4.__________ 5.___________
//1. 捕捉列表: [ …] lamda表达式 以[]开始 [ ] 里面的内容用,分隔
//[ = ] 以值传递来捕捉所有变量
//[ & ] 以引用传递捕捉所有变量
//[ val ] 捕捉某val变量 , 值传递
//[ &val ] 捕捉某val变量的引用, 引用传递
//捕捉列表作用, 函数可以使用全局变量或外面的变量不过使用之前, 要提前告诉捕捉列表 , 需要提前登记
//要是用栈区变量, 需要在捕捉列表登记, 静态和全局不用登记也能用
//lamda表达式 以[]开始 , [] 不可以省略
//问题举例:
//[ = , val ] 出现歧义 , 有问题 ×
//[ = , & ] 值传递还是引用? 有问题 ×
//[ = , &val ] 可以 √ val以外的用值传递, val是引用传递
//2.参数列表
//函数的参数列表, 可以写多个参数, 参数列表可以省略( ) 和形参 , 也就是第二部分全省略 ,
//但是如果有mutable 修饰词, 第二部分不可省略,至少要有( )
//3.mutable 可变的 交代是否是常函数
//mutable 当不写这个词, 意味着这个lamda表达式说明的函数,他是一个常函数 (不可以改变变量)
//错误例子:
//int a= 3;
//auto func = [ = ] () { a = 10;} =代表是值传递 , 没有mutable , 常函数 , a=10; 操作是不可以的, 所以该式子非法
//--------------------------------------
//auto func = [ & ] () { a = 10;} &即使没有mutable也可以有赋值 a的值会发生改变
//auto func = [ = ] ()mutable { a = 10;} 有mutable 可以有赋值, 不过是值传递, a的值还是3
//auto func = [ & ] ()mutable { a = 10;} 有mutable 可以有赋值, 引用传递 , a的值变为10
//4.返回值
//返回值可以省略, 如果函数体里面有返回值, 第四部分也可以不写 , 系统自动默认返回值类型
//auto func = [ = ] ()mutable { return a = 10;} 对
//5.函数体
//跟正常的函数没什么区别.
static int i = 10;
int j = 20;
auto f2 = { return i;}; //对 虽然没有捕捉, 但是他是全局的好使
cout<< f2( ) <<endl; //10
auto f3 = j { return j;};
auto f4 = f3;
// auto f1 = { return j;}; //错误 捕捉列表没有
// auto f5 = [j]{ j =30;} // 没有mutable 他是常函数 错误
分区 0106 的第 21 页
auto f6 = [ &j ]{ return j = 30;}; //没有mutable
//cout << "f6 "<<f6() << " " << j <<endl; // 输出 30 , 20
//cout 从右向左执行在函数执行前读取j,输出与之前保持一致
cout << j << " f6 "<<f6() << " " << endl; // 输出 30 , 30
cout << j <<endl; //输出30 引用函数调用后修改了j
// auto f5 = [j]{ j =30;} // 没有mutable 他是常函数 错误
auto f7 = [ j ] ()mutable { return j =50;}; //mutable修饰
//此时可以有赋值, 不过是值传递, 不会修改
//cout <<"f7 "<< f7() << " " << j <<endl;
cout << j << " f7 "<<f7() << " " << endl; //
cout << j <<endl;
auto f8 = &j mutable{ return j = 10;};
cout <<"f8 "<< f8() << " " << j <<endl;
cout << j <<endl;