泛型算法和函数对象（待完善），智能指针

泛型算法和函数对象

头文件：
#include
#include

泛型算法：
copy
find
sort
find_if

函数对象：
less <
greater >
binderlst
binder2nd

int main()
{
    vector<int> v1;
    for(int i=0;i<10;++i)
    {
       v1.push_back();
    }
    
copy
   copy(v1.begin(),v1.end(),ostream_iterator<int>(cout," "));输出v1
   
   vector<int> v2;
   copy(v1.begin(),v1.end(),inserter(v2,v2.begin()));拷贝到v2
                            第三个参数是插入型迭代器
                            
find
   vector<int>::iterator it=find(v1.begin(),v1.end(),5)返回迭代器
    if(it==v1.end())没找到就是end
    {
       cout<<"no find"<<endl;
    } else
    {
      cout<<*it;
    }
    
sort排序
   sort(v1.begin(),v1.end())；默认从小到大
   
find_if小于或大于的数
   vector<int>::iterator it=find_if(v1.begin().v1.end(),binder2nd<less<int>> (less<int>(),10));
   找到容器中第一个小于10的数
	if(it==v1.end())
	{
	  cout<<"not find";
	}else
	{
	   cout<<*it<<endl;
	}       
          
   
}

cin 和 scanf输入都存在一个问题，遇到空格都会刷新缓冲区，因此无法获取带空格的字符串。
解决方法：cin.getline();获取一行，遇到换行符才会刷新缓冲区

RAII:堆上空间自动管理–利用对象自动析构的机制

智能指针auto_ptr:

1.函数结束后，智能指针会帮忙析构，但不可多个智能指针用一个初始化，会析构多次报错

2.允许拷贝构造(用已存在的智能指针对正在生成的进行构造)和等号运算符，但会将原智能指针置空。

auto_ptr代码（已废弃）

#include<memory>智能指针头文件
int main()
{
    int* p=new int(10);
    
    auto_ptr<int> a_p(p);
    auto_ptr<int> a_p=p;错误，这是隐式构造，智能指针定义时在函数名最前面加了explicit,防止隐式构造
    p生成临时对象再用该对象拷贝构造，最后析构，优化为直接构造a_p,这是隐式构造
    
    cout<<*a_p<<endl;10 
    
    auto_ptr<int> a_p2;=运算符重载
    a_p2=a_p;不会报错
    
    auto_ptr<int> a_p1(a_p);不会报错，拷贝构造

     a_p.release();将原来的智能指针置空，定义一个临时智能指针（函数内），让它指向智能指针原来指向的地方，并返回该指针（也就是返回指向的地址）

     a_p.reset();将当前智能指针指向的内存释放，并将该智能指针置空

    a_p.get();获取智能指针内部指针
}

智能指针 unique_ptr代码

右值引用用来引用即将死亡的对象(临时对象)
int &&b=10;右值引用(b引用10产生的临时对象)

unique_ptr知识点
1.不能用一个指针多次初始化多个智能指针
2.不允许隐式构造
3.不允许拷贝构造，不允许等号运算符重载
4.有右值拷贝构造的可以

void fun()
{
   int* p=new int(10);
   unique_ptr<int> u_p(p);
   cout<<*p<<endl;10
   cout<<*u_p<<endl;10
   unique_ptr<int> u_p1(u_p);崩溃，第三点
   unique_ptr<int>u_p1=p;隐式构造
   u_p.get();获取内部指针
   u_p.release();返回智能指针指向的地方的地址并将该智能指针置空
   u_p.reset();释放指向的空间并将智能指针置空
   u_p.swap(u_p3);交换指向的地方
    
  右值引用
  unique_ptr<int> fun(unique_ptr<int>& ptr)
  {
    int* p=new int(9);
    return unique_ptr<int> (p);
  }  
  unique_ptr<int> u_p2(fun(u_p));
  cout<<*u_p2<<endl;
  上面代码中使用了拷贝构造，但不会报错，因为拷贝构造用的是临时对象拷贝构造的u_p2,
  也就是右值引用。 

bool运算符重载
    if(u_p)判断u_p是否为空
  
}

template<class T,class D>
class my_unique_ptr<T*,D*>部分特化版本，当实参为两个指针时调用它
{
   my_unique_ptr(){cout<<"T*,D*"<<endl;};
}
my_unique_ptr<int*,int*> a,调用上面的部分特化版本，当无上面那个版本时，就会调用下面那个版本，就是说有完全符合的参数就去调用符合的，如果无只要是参数就可。
template<class T,class D>
class my_unique_ptr
{
   public:
      my_unique_ptr(){cout<<"T,D"<<endl;};
      
}
int main()
{
   my_unique_ptr<int,int> a;
}
template<class T,class D>完全特化版本
class my_unique_ptr<const char*,const char*>
{
   同上
}


C11标准中的特化版本，可以解决删除多个还是一个对象的问题

shared_ptr强智能指针

1.不允许隐式构造
2.不允许用一个指针初始化多个智能指针
3.允许拷贝构造和等号运算符重载

void fun()
{
    int* p=new int(11);
    shared_ptr<int> s_p(p);
    cout<<*p<<endl;11
    cout<<*s_p<<endl;11
    
    shared_ptr<int> s_p1(s_p);不会报错 拷贝构造
    s_p=s_p1;不会报错  =运算符重载

    s_p.use_cout();指向同一块地方的智能指针的个数
    
    s_p.unique();判断是不是唯一的，只有它一个智能指针指向
    s_p.reset();
 }

weak_ptr弱智能指针

不能直接使用，如果要用得转为强智能指针